diff options
Diffstat (limited to 'src/prefetcher/main.cc')
| -rw-r--r-- | src/prefetcher/main.cc | 190 |
1 files changed, 190 insertions, 0 deletions
diff --git a/src/prefetcher/main.cc b/src/prefetcher/main.cc new file mode 100644 index 0000000..94ba141 --- /dev/null +++ b/src/prefetcher/main.cc @@ -0,0 +1,190 @@ +// Copyright (C) 2019 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "common/debug.h" +#include "common/loggers.h" +#include "prefetcher/prefetcher_daemon.h" + +#include <android-base/parseint.h> +#include <android-base/logging.h> + +#include <iostream> +#include <optional> +#include <string_view> +#include <string> +#include <vector> + +#include <signal.h> + +#if defined(IORAP_PREFETCHER_MAIN) + +namespace iorap::prefetcher { + +void Usage(char** argv) { + std::cerr << "Usage: " << argv[0] << " [--input-fd=#] [--output-fd=#]" << std::endl; + std::cerr << "" << std::endl; + std::cerr << " Run the readahead daemon which can prefetch files given a command." << std::endl; + std::cerr << "" << std::endl; + std::cerr << " Optional flags:" << std::endl; + std::cerr << " --help,-h Print this Usage." << std::endl; + std::cerr << " --input-fd,-if Input FD (default stdin)." << std::endl; + std::cerr << " --output-fd,-of Output FD (default stdout)." << std::endl; + std::cerr << " --use-sockets,-us Use AF_UNIX sockets (default off)." << std::endl; + std::cerr << " --command-format=[text|binary],-cf (default text)." << std::endl; + std::cerr << " --verbose,-v Set verbosity (default off)." << std::endl; + std::cerr << " --wait,-w Wait for key stroke before continuing (default off)." << std::endl; + exit(1); +} + +int Main(int argc, char** argv) { + // Go to system logcat + stderr when running from command line. + android::base::InitLogging(argv, iorap::common::StderrAndLogdLogger{android::base::SYSTEM}); + + bool wait_for_keystroke = false; + bool enable_verbose = false; + + bool command_format_text = false; // false = binary. + + int arg_input_fd = -1; + int arg_output_fd = -1; + + std::vector<std::string> arg_input_filenames; + bool arg_use_sockets = false; + + LOG(VERBOSE) << "argparse: argc=" << argc; + + for (int arg = 1; arg < argc; ++arg) { + std::string argstr = argv[arg]; + bool has_arg_next = (arg+1)<argc; + std::string arg_next = has_arg_next ? argv[arg+1] : ""; + + LOG(VERBOSE) << "argparse: argv[" << arg << "]=" << argstr; + + if (argstr == "--help" || argstr == "-h") { + Usage(argv); + } else if (argstr == "--input-fd" || argstr == "-if") { + if (!has_arg_next) { + LOG(ERROR) << "--input-fd=<numeric-value>"; + Usage(argv); + } + if (!::android::base::ParseInt(arg_next, /*out*/&arg_input_fd)) { + LOG(ERROR) << "--input-fd value must be numeric"; + Usage(argv); + } + } else if (argstr == "--output-fd" || argstr == "-of") { + if (!has_arg_next) { + LOG(ERROR) << "--output-fd=<numeric-value>"; + Usage(argv); + } + if (!::android::base::ParseInt(arg_next, /*out*/&arg_output_fd)) { + LOG(ERROR) << "--output-fd value must be numeric"; + Usage(argv); + } + } else if (argstr == "--command-format=" || argstr == "-cf") { + if (!has_arg_next) { + LOG(ERROR) << "--command-format=text|binary"; + Usage(argv); + } + if (arg_next == "text") { + command_format_text = true; + } else if (arg_next == "binary") { + command_format_text = false; + } else { + LOG(ERROR) << "--command-format must be one of {text,binary}"; + Usage(argv); + } + } else if (argstr == "--use-sockets" || argstr == "-us") { + arg_use_sockets = true; + } else if (argstr == "--verbose" || argstr == "-v") { + enable_verbose = true; + } else if (argstr == "--wait" || argstr == "-w") { + wait_for_keystroke = true; + } else { + arg_input_filenames.push_back(argstr); + } + } + + if (enable_verbose) { + android::base::SetMinimumLogSeverity(android::base::VERBOSE); + + LOG(VERBOSE) << "Verbose check"; + LOG(VERBOSE) << "Debug check: " << ::iorap::kIsDebugBuild; + } else { + android::base::SetMinimumLogSeverity(android::base::DEBUG); + } + + LOG(VERBOSE) << "argparse: argc=" << argc; + + for (int arg = 1; arg < argc; ++arg) { + std::string argstr = argv[arg]; + + LOG(VERBOSE) << "argparse: argv[" << arg << "]=" << argstr; + } + + // Useful to attach a debugger... + // 1) $> iorap.cmd.readahead -w <args> + // 2) $> gdbclient <pid> + if (wait_for_keystroke) { + LOG(INFO) << "Self pid: " << getpid(); + + raise(SIGSTOP); + // LOG(INFO) << "Press any key to continue..."; + // std::cin >> wait_for_keystroke; + } + + // auto system_call = std::make_unique<SystemCallImpl>(); + // TODO: mock readahead calls? + // + // Uncomment this if we want to leave the process around to inspect it from adb shell. + // sleep(100000); + + int return_code = 0; + + LOG(VERBOSE) << "Hello world"; + + if (arg_input_fd == -1) { + arg_input_fd = STDIN_FILENO; + } + if (arg_output_fd == -1) { + arg_output_fd = STDOUT_FILENO; + } + + PrefetcherForkParameters params{}; + params.input_fd = arg_input_fd; + params.output_fd = arg_output_fd; + params.format_text = command_format_text; + params.use_sockets = arg_use_sockets; + + LOG(VERBOSE) << "main: Starting PrefetcherDaemon: " + << "input_fd=" << params.input_fd + << ",output_fd=" << params.output_fd; + { + PrefetcherDaemon daemon; + // Blocks until receiving an exit command. + daemon.Main(std::move(params)); + } + LOG(VERBOSE) << "main: Terminating"; + + // 0 -> successfully executed all commands. + // 1 -> failed along the way (#on_error and also see the error logs). + return return_code; +} + +} // namespace iorap::prefetcher + +int main(int argc, char** argv) { + return ::iorap::prefetcher::Main(argc, argv); +} + +#endif // IORAP_PREFETCHER_MAIN |