| // Copyright 2014 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chrome/browser/ash/system_logs/debug_log_writer.h" |
| |
| #include <stdint.h> |
| #include <utility> |
| |
| #include "base/command_line.h" |
| #include "base/files/file.h" |
| #include "base/files/file_util.h" |
| #include "base/functional/bind.h" |
| #include "base/functional/callback.h" |
| #include "base/functional/callback_helpers.h" |
| #include "base/process/kill.h" |
| #include "base/process/launch.h" |
| #include "base/task/lazy_thread_pool_task_runner.h" |
| #include "base/task/sequenced_task_runner.h" |
| #include "base/task/thread_pool.h" |
| #include "chrome/common/logging_chrome.h" |
| #include "chromeos/ash/components/dbus/debug_daemon/debug_daemon_client.h" |
| #include "content/public/browser/browser_task_traits.h" |
| #include "content/public/browser/browser_thread.h" |
| |
| namespace ash { |
| namespace debug_log_writer { |
| |
| namespace { |
| |
| using StoreLogsCallback = |
| base::OnceCallback<void(std::optional<base::FilePath> log_path)>; |
| |
| // Callback for returning status of executed external command. |
| typedef base::OnceCallback<void(bool succeeded)> CommandCompletionCallback; |
| |
| const char kGzipCommand[] = "/bin/gzip"; |
| const char kTarCommand[] = "/bin/tar"; |
| |
| base::LazyThreadPoolSequencedTaskRunner g_sequenced_task_runner = |
| LAZY_THREAD_POOL_SEQUENCED_TASK_RUNNER_INITIALIZER( |
| base::TaskTraits(base::MayBlock(), |
| base::TaskPriority::BEST_EFFORT, |
| base::TaskShutdownBehavior::BLOCK_SHUTDOWN)); |
| |
| // Called upon completion of |WriteDebugLogToFile|. Closes file |
| // descriptor, deletes log file in the case of failure and calls |
| // |callback|. |
| void WriteDebugLogToFileCompleted(const base::FilePath& file_path, |
| StoreLogsCallback callback, |
| bool succeeded) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| if (!succeeded) { |
| bool posted = g_sequenced_task_runner.Get()->PostTask( |
| FROM_HERE, |
| base::GetDeleteFileCallback( |
| file_path, |
| base::OnceCallback<void(bool)>(base::DoNothing()) |
| .Then(base::BindOnce(std::move(callback), std::nullopt)))); |
| DCHECK(posted); |
| return; |
| } |
| if (!callback.is_null()) |
| std::move(callback).Run(file_path); |
| } |
| |
| // Stores debug logs into |file_path| as a tar file. Invokes |callback| upon |
| // completion. |
| void WriteDebugLogToFile(std::unique_ptr<base::File> file, |
| const base::FilePath& file_path, |
| bool should_compress, |
| StoreLogsCallback callback) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| if (!file->IsValid()) { |
| LOG(ERROR) << "Can't create debug log file: " << file_path.AsUTF8Unsafe() |
| << ", error: " << file->error_details(); |
| return; |
| } |
| ash::DebugDaemonClient::Get()->DumpDebugLogs( |
| should_compress, file->GetPlatformFile(), |
| base::BindOnce(&WriteDebugLogToFileCompleted, file_path, |
| std::move(callback))); |
| |
| // Close the file on an IO-allowed thread. |
| g_sequenced_task_runner.Get()->DeleteSoon(FROM_HERE, file.release()); |
| } |
| |
| // Runs command with its parameters as defined in |argv|. |
| // Upon completion, it will report command run outcome via |callback| on the |
| // same thread from where it was initially called from. |
| void RunCommand(const std::vector<std::string>& argv, |
| CommandCompletionCallback callback) { |
| base::Process process = base::LaunchProcess(argv, base::LaunchOptions()); |
| if (!process.IsValid()) { |
| LOG(ERROR) << "Failed to execute command " << argv[0]; |
| if (!callback.is_null()) |
| std::move(callback).Run(false); |
| |
| return; |
| } |
| |
| int exit_code = 0; |
| base::internal::GetAppOutputScopedAllowBaseSyncPrimitives allow_wait; |
| if (!process.WaitForExit(&exit_code)) { |
| LOG(ERROR) << "Can't get exit code for pid " << process.Pid(); |
| if (!callback.is_null()) |
| std::move(callback).Run(false); |
| |
| return; |
| } |
| if (!callback.is_null()) |
| std::move(callback).Run(exit_code == 0); |
| } |
| |
| // Callback for handling the outcome of CompressArchive(). It reports |
| // the final outcome of log retreival process at via |callback|. |
| void OnCompressArchiveCompleted(const base::FilePath& tar_file_path, |
| const base::FilePath& compressed_output_path, |
| StoreLogsCallback callback, |
| bool compression_command_success) { |
| if (!compression_command_success) { |
| LOG(ERROR) << "Failed compressing " << compressed_output_path.value(); |
| content::GetUIThreadTaskRunner({})->PostTask( |
| FROM_HERE, base::BindOnce(std::move(callback), std::nullopt)); |
| base::DeleteFile(tar_file_path); |
| base::DeleteFile(compressed_output_path); |
| return; |
| } |
| |
| content::GetUIThreadTaskRunner({})->PostTask( |
| FROM_HERE, base::BindOnce(std::move(callback), compressed_output_path)); |
| } |
| |
| // Gzips |tar_file_path| and stores results in |compressed_output_path|. |
| void CompressArchive(const base::FilePath& tar_file_path, |
| const base::FilePath& compressed_output_path, |
| StoreLogsCallback callback, |
| bool add_user_logs_command_success) { |
| if (!add_user_logs_command_success) { |
| LOG(ERROR) << "Failed adding user logs to " << tar_file_path.value(); |
| content::GetUIThreadTaskRunner({})->PostTask( |
| FROM_HERE, base::BindOnce(std::move(callback), std::nullopt)); |
| base::DeleteFile(tar_file_path); |
| return; |
| } |
| |
| std::vector<std::string> argv; |
| argv.push_back(kGzipCommand); |
| argv.push_back(tar_file_path.value()); |
| RunCommand(argv, base::BindOnce(&OnCompressArchiveCompleted, tar_file_path, |
| compressed_output_path, std::move(callback))); |
| } |
| |
| // Adds user sessions specific logs from |user_log_dir| into tar archive file |
| // at |tar_file_path|. Upon completion, it will call CompressArchive() to |
| // produce |compressed_output_path|. |
| void AddUserLogsToArchive(const base::FilePath& user_log_dir, |
| const base::FilePath& tar_file_path, |
| StoreLogsCallback callback) { |
| std::vector<std::string> argv; |
| argv.push_back(kTarCommand); |
| argv.push_back("-rvf"); |
| argv.push_back(tar_file_path.value()); |
| argv.push_back(user_log_dir.value()); |
| base::FilePath compressed_output_path = |
| tar_file_path.AddExtension(FILE_PATH_LITERAL(".gz")); |
| RunCommand(argv, base::BindOnce(&CompressArchive, tar_file_path, |
| compressed_output_path, std::move(callback))); |
| } |
| |
| // Appends user logs after system logs are archived into |tar_file_path|. |
| void OnSystemLogsAdded(StoreLogsCallback callback, |
| std::optional<base::FilePath> tar_file_path) { |
| if (!tar_file_path) { |
| if (!callback.is_null()) |
| std::move(callback).Run(std::nullopt); |
| return; |
| } |
| |
| base::FilePath user_log_dir = |
| logging::GetSessionLogDir(*base::CommandLine::ForCurrentProcess()); |
| |
| base::ThreadPool::PostTask( |
| FROM_HERE, {base::MayBlock(), base::TaskPriority::BEST_EFFORT}, |
| base::BindOnce(&AddUserLogsToArchive, user_log_dir, *tar_file_path, |
| std::move(callback))); |
| } |
| |
| void InitializeLogFile(base::File* file, |
| const base::FilePath& file_path, |
| uint32_t flags) { |
| base::FilePath dir = file_path.DirName(); |
| if (!base::DirectoryExists(dir)) { |
| if (!base::CreateDirectory(dir)) { |
| LOG(ERROR) << "Can not create " << dir.value(); |
| return; |
| } |
| } |
| |
| file->Initialize(file_path, flags); |
| } |
| |
| // Starts logs retrieval process. The output will be stored in file with name |
| // derived from |file_name_template|. |
| void StartLogRetrieval(const base::FilePath& file_name_template, |
| bool should_compress, |
| StoreLogsCallback callback) { |
| base::FilePath file_path = |
| logging::GenerateTimestampedName(file_name_template, base::Time::Now()); |
| |
| int flags = base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE; |
| std::unique_ptr<base::File> file(new base::File); |
| base::File* file_ptr = file.get(); |
| g_sequenced_task_runner.Get()->PostTaskAndReply( |
| FROM_HERE, |
| base::BindOnce(&InitializeLogFile, base::Unretained(file_ptr), file_path, |
| flags), |
| base::BindOnce(&WriteDebugLogToFile, std::move(file), file_path, |
| should_compress, std::move(callback))); |
| } |
| |
| } // namespace |
| |
| // static. |
| void StoreLogs(const base::FilePath& out_dir, |
| bool include_chrome_logs, |
| base::OnceCallback<void(std::optional<base::FilePath> logs_path)> |
| callback) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| DCHECK(!callback.is_null()); |
| |
| if (include_chrome_logs) { |
| base::FilePath file_path = |
| out_dir.Append(FILE_PATH_LITERAL("combined-logs.tar")); |
| // Get system logs from /var/log first, then add user-specific stuff. |
| StartLogRetrieval(file_path, /*should_compress=*/false, |
| base::BindOnce(&OnSystemLogsAdded, std::move(callback))); |
| } else { |
| base::FilePath file_path = |
| out_dir.Append(FILE_PATH_LITERAL("debug-logs.tgz")); |
| StartLogRetrieval(file_path, /*should_compress=*/true, std::move(callback)); |
| } |
| } |
| |
| } // namespace debug_log_writer |
| } // namespace ash |