// 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
Codebase Browser
chromium