src/inode2filename/out_of_process_inode_resolver.cc - platform/system/iorap - Git at Google

 // Copyright (C) 2020 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/cmd_utils.h"
 #include "inode2filename/inode_resolver.h"
 #include "inode2filename/out_of_process_inode_resolver.h"

 #include <android-base/file.h>
 #include <android-base/logging.h>
 #include <android-base/unique_fd.h>

 #include <sstream>
 #include <stdio.h>
 #include <unistd.h>

 namespace rx = rxcpp;

 namespace iorap::inode2filename {

 using ::android::base::unique_fd;
 using ::android::base::borrowed_fd;

 static const char* GetCommandFileName() {
   // Avoid ENOENT by execve by specifying the absolute path of inode2filename.
 #ifdef __ANDROID__
   return "/system/bin/iorap.inode2filename";
 #else
   static const char* file_name = nullptr;

   if (file_name == nullptr) {
     char* out_dir = getenv("ANDROID_HOST_OUT");
     static std::string file_name_str = out_dir;
     if (out_dir != nullptr) {
       file_name_str += "/bin/";
     } else {
       // Assume it's in the same directory as the binary we are in.
       std::string self_path;
       CHECK(::android::base::Readlink("/proc/self/exe", /*out*/&self_path));

       std::string self_dir = ::android::base::Dirname(self_path);
       file_name_str = self_dir + "/";
     }
     file_name_str += "iorap.inode2filename";

     file_name = file_name_str.c_str();
   }

   return file_name;
 #endif
 }

 std::error_code ErrorCodeFromErrno() {
   int err = errno;
   return std::error_code(err, std::system_category());
 }

 std::ios_base::failure IosBaseFailureWithErrno(const char* message) {
   std::error_code ec = ErrorCodeFromErrno();
   return std::ios_base::failure(message, ec);
 }

 static constexpr bool kDebugFgets = false;

 int32_t ReadLineLength(FILE* stream, bool* eof) {
   char buf[sizeof(int32_t)];
   size_t count = fread(buf, 1, sizeof(int32_t), stream);
   if (feof(stream)) {
     // If reaching the end of the stream when trying to read the first int, just
     // return. This is legitimate, because after reading the last line, the next
     // iteration will reach this.
     *eof = true;
     return 0;
   }
   int32_t length;
   memcpy(&length, buf, sizeof(int32_t));
   return length;
 }

 // The steam is like [size1][file1][size2][file2]...[sizeN][fileN].
 std::string ReadOneLine(FILE* stream, bool* eof) {
   DCHECK(stream != nullptr);
   DCHECK(eof != nullptr);

   int32_t length = ReadLineLength(stream, eof);
   if (length <= 0) {
     PLOG(ERROR) << "unexpected 0 length line.";
     *eof = true;
     return "";
   }

   std::string str(length, '\0');
   size_t count = fread(&str[0], sizeof(char), length, stream);
   if (feof(stream) || ferror(stream) || count != (uint32_t)length) {
     // error! :(
     PLOG(ERROR) << "unexpected end of the line during fread";
     *eof = true;
     return "";
   }
   return str;
 }

 static inline void LeftTrim(/*inout*/std::string& s) {
   s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
     return !std::isspace(ch);
   }));
 }

 // Parses an --output-format=ipc kind of line into an InodeResult.
 // Returns nullopt if parsing failed.
 std::optional<InodeResult> ParseFromLine(const std::string& line) {
   // inode <- INT:INT:INT
   // line_ok <- 'K ' inode ' ' STRING
   // line_err <- 'E ' inode ' ' INT
   //
   // result <- line_ok | line_err

   std::stringstream ss{line};

   bool result_ok = false;

   std::string ok_or_error;
   ss >> ok_or_error;

   if (ss.fail()) {
     return std::nullopt;
   }

   if (ok_or_error == "K") {
     result_ok = true;
   } else if (ok_or_error == "E") {
     result_ok = false;
   } else {
     return std::nullopt;
   }

   std::string inode_s;
   ss >> inode_s;

   if (ss.fail()) {
     return std::nullopt;
   }

   Inode inode;

   std::string inode_parse_error_msg;
   if (!Inode::Parse(inode_s, /*out*/&inode, /*out*/&inode_parse_error_msg)) {
     return std::nullopt;
   }

   if (result_ok == false) {
     int error_code;
     ss >> error_code;

     if (ss.fail()) {
       return std::nullopt;
     }

     return InodeResult::makeFailure(inode, error_code);
   } else if (result_ok == true) {
     std::string rest_of_line;
     ss >> rest_of_line;

     // parse " string with potential spaces"
     // into "string with potential spaces"
     LeftTrim(/*inout*/rest_of_line);

     if (ss.fail()) {
       return std::nullopt;
     }

     const std::string& file_name = rest_of_line;

     return InodeResult::makeSuccess(inode, file_name);
   }

   return std::nullopt;
 }

 struct OutOfProcessInodeResolver::Impl {
   Impl() {
   }

  private:
   // Create the argv we will pass to the forked inode2filename, corresponds to #EmitAll.
   std::vector<std::string> CreateArgvAll(const InodeResolverDependencies& deps) const {
     std::vector<std::string> argv;
     argv.push_back("--all");

     return CreateArgv(deps, std::move(argv));
   }

   // Create the argv we will pass to the forked inode2filename, corresponds to
   // #FindFilenamesFromInodes.
   std::vector<std::string> CreateArgvFind(const InodeResolverDependencies& deps,
                                           const std::vector<Inode>& inodes) const {
     std::vector<std::string> argv;
     iorap::common::AppendArgsRepeatedly(argv, inodes);

     return CreateArgv(deps, std::move(argv));
   }

   std::vector<std::string> CreateArgv(const InodeResolverDependencies& deps,
                                       std::vector<std::string> append_argv) const {
     InodeResolverDependencies deps_oop = deps;
     deps_oop.process_mode = ProcessMode::kInProcessDirect;

     std::vector<std::string> argv = ToArgs(deps_oop);

     argv.push_back("--output-format=ipc");

     if (iorap::common::GetBoolEnvOrProperty("iorap.inode2filename.log.verbose", false)) {
       argv.push_back("--verbose");
     }

     iorap::common::AppendArgsRepeatedly(argv, std::move(append_argv));

     return argv;
   }

  public:
   // fork+exec into inode2filename with 'inodes' as the search list.
   // Each result is parsed into a dest#on_next(result).
   // If a fatal error occurs, dest#on_error is called once and no other callbacks are called.
   void EmitFromCommandFind(rxcpp::subscriber<InodeResult>& dest,
                            const InodeResolverDependencies& deps,
                            const std::vector<Inode>& inodes) {
     // Trivial case: complete immediately.
     // Executing inode2filename with empty search list will just print the --help menu.
     if (inodes.empty()) {
       dest.on_completed();
     }

     std::vector<std::string> argv = CreateArgvFind(deps, inodes);
     EmitFromCommandWithArgv(/*inout*/dest, std::move(argv), inodes.size());
   }

   // fork+exec into inode2filename with --all (listing *all* inodes).
   // Each result is parsed into a dest#on_next(result).
   // If a fatal error occurs, dest#on_error is called once and no other callbacks are called.
   void EmitFromCommandAll(rxcpp::subscriber<InodeResult>& dest,
                            const InodeResolverDependencies& deps) {
     std::vector<std::string> argv = CreateArgvAll(deps);
     EmitFromCommandWithArgv(/*inout*/dest, std::move(argv), /*result_count*/std::nullopt);
   }

  private:
   void EmitFromCommandWithArgv(rxcpp::subscriber<InodeResult>& dest,
                                std::vector<std::string> argv_vec,
                                std::optional<size_t> result_count) {
     unique_fd pipe_reader, pipe_writer;
     if (!::android::base::Pipe(/*out*/&pipe_reader, /*out*/&pipe_writer)) {
       dest.on_error(
           rxcpp::util::make_error_ptr(
               IosBaseFailureWithErrno("Failed to create out-going pipe for inode2filename")));
       return;
     }

     pid_t child = fork();
     if (child == -1) {
       dest.on_error(
           rxcpp::util::make_error_ptr(
               IosBaseFailureWithErrno("Failed to fork process for inode2filename")));
       return;
     } else if (child > 0) {  // we are the caller of this function
       LOG(DEBUG) << "forked into a process for inode2filename , pid = " << child;
     } else {
       // we are the child that was forked

       const char* kCommandFileName = GetCommandFileName();

       std::stringstream argv; // for debugging.
       for (std::string arg : argv_vec) {
         argv  << arg << ' ';
       }
       LOG(DEBUG) << "fork+exec: " << kCommandFileName << " " << argv.str();

       // Redirect only stdout. stdin is unused, stderr is same as parent.
       if (dup2(pipe_writer.get(), STDOUT_FILENO) == -1) {
         // Trying to call #on_error does not make sense here because we are in a forked process,
         // the only thing we can do is crash definitively.
         PLOG(FATAL) << "Failed to dup2 for inode2filename";
       }

       std::unique_ptr<const char *[]> argv_ptr =
                 common::VecToArgv(kCommandFileName, argv_vec);

       if (execve(kCommandFileName,
                  (char **)argv_ptr.get(),
                  /*envp*/nullptr) == -1) {
         // Trying to call #on_error does not make sense here because we are in a forked process,
         // the only thing we can do is crash definitively.
         PLOG(FATAL) << "Failed to execve process for inode2filename";
       }
       // This should never return.
     }

     // Immediately close the writer end of the pipe because we never use it.
     pipe_writer.reset();

     // Convert pipe(reader) file descriptor into FILE*.
     std::unique_ptr<FILE, int(*)(FILE*)> file_reader{
         ::android::base::Fdopen(std::move(pipe_reader), /*mode*/"r"), fclose};
     if (!file_reader) {
       dest.on_error(
           rxcpp::util::make_error_ptr(
               IosBaseFailureWithErrno("Failed to fdopen for inode2filename")));
       return;
     }

     size_t actual_result_count = 0;

     bool file_eof = false;
     while (!file_eof) {
       std::string inode2filename_line = ReadOneLine(file_reader.get(), /*out*/&file_eof);

       if (inode2filename_line.empty()) {
         if (!file_eof) {
           // Ignore empty lines.
           LOG(WARNING) << "inode2filename: got empty line";
         }
         continue;
       }

       LOG(DEBUG) << "inode2filename output-line: " << inode2filename_line;

       std::optional<InodeResult> res = ParseFromLine(inode2filename_line);
       if (!res) {
         std::string error_msg = "Invalid output: ";
         error_msg += inode2filename_line;
         dest.on_error(
             rxcpp::util::make_error_ptr(std::ios_base::failure(error_msg)));
         return;
       }
       dest.on_next(*res);

       ++actual_result_count;
     }

     LOG(DEBUG) << "inode2filename output-eof";

     // Ensure that the # of inputs into the rx stream match the # of outputs.
     // This is validating the post-condition of FindFilenamesFromInodes.
     if (result_count && actual_result_count != *result_count) {
       std::stringstream ss;
       ss << "Invalid number of results, expected: " << *result_count;
       ss << ", actual: " << actual_result_count;

       dest.on_error(
           rxcpp::util::make_error_ptr(std::ios_base::failure(ss.str())));
       return;
     }

     CHECK(child > 0);  // we are in the parent process, parse the IPC output of inode2filename
     dest.on_completed();
   }
 };

 rxcpp::observable<InodeResult>
     OutOfProcessInodeResolver::FindFilenamesFromInodes(std::vector<Inode> inodes) const {
   return rxcpp::observable<>::create<InodeResult>(
     [self=std::static_pointer_cast<const OutOfProcessInodeResolver>(shared_from_this()),
      inodes=std::move(inodes)](
         rxcpp::subscriber<InodeResult> s) {
       self->impl_->EmitFromCommandFind(s, self->GetDependencies(), inodes);
   });
 }

 rxcpp::observable<InodeResult>
     OutOfProcessInodeResolver::EmitAll() const {
   auto self = std::static_pointer_cast<const OutOfProcessInodeResolver>(shared_from_this());
   CHECK(self != nullptr);
   CHECK(self->impl_ != nullptr);

   return rxcpp::observable<>::create<InodeResult>(
     [self](rxcpp::subscriber<InodeResult> s) {
       CHECK(self != nullptr);
       CHECK(self->impl_ != nullptr);
       self->impl_->EmitFromCommandAll(s, self->GetDependencies());
   });
 }

 OutOfProcessInodeResolver::OutOfProcessInodeResolver(InodeResolverDependencies dependencies)
   : InodeResolver{std::move(dependencies)}, impl_{new Impl{}} {
 }

 OutOfProcessInodeResolver::~OutOfProcessInodeResolver() {
   // std::unique_ptr requires complete types, but we hide the definition in the header.
   delete impl_;
 }

 }  // namespace iorap::inode2filename
	// Copyright (C) 2020 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/cmd_utils.h"
	#include "inode2filename/inode_resolver.h"
	#include "inode2filename/out_of_process_inode_resolver.h"

	#include <android-base/file.h>
	#include <android-base/logging.h>
	#include <android-base/unique_fd.h>

	#include <sstream>
	#include <stdio.h>
	#include <unistd.h>

	namespace rx = rxcpp;

	namespace iorap::inode2filename {

	using ::android::base::unique_fd;
	using ::android::base::borrowed_fd;

	static const char* GetCommandFileName() {
	// Avoid ENOENT by execve by specifying the absolute path of inode2filename.
	#ifdef __ANDROID__
	return "/system/bin/iorap.inode2filename";
	#else
	static const char* file_name = nullptr;

	if (file_name == nullptr) {
	char* out_dir = getenv("ANDROID_HOST_OUT");
	static std::string file_name_str = out_dir;
	if (out_dir != nullptr) {
	file_name_str += "/bin/";
	} else {
	// Assume it's in the same directory as the binary we are in.
	std::string self_path;
	CHECK(::android::base::Readlink("/proc/self/exe", /out/&self_path));

	std::string self_dir = ::android::base::Dirname(self_path);
	file_name_str = self_dir + "/";
	}
	file_name_str += "iorap.inode2filename";

	file_name = file_name_str.c_str();
	}

	return file_name;
	#endif
	}

	std::error_code ErrorCodeFromErrno() {
	int err = errno;
	return std::error_code(err, std::system_category());
	}

	std::ios_base::failure IosBaseFailureWithErrno(const char* message) {
	std::error_code ec = ErrorCodeFromErrno();
	return std::ios_base::failure(message, ec);
	}

	static constexpr bool kDebugFgets = false;

	int32_t ReadLineLength(FILE* stream, bool* eof) {
	char buf[sizeof(int32_t)];
	size_t count = fread(buf, 1, sizeof(int32_t), stream);
	if (feof(stream)) {
	// If reaching the end of the stream when trying to read the first int, just
	// return. This is legitimate, because after reading the last line, the next
	// iteration will reach this.
	*eof = true;
	return 0;
	}
	int32_t length;
	memcpy(&length, buf, sizeof(int32_t));
	return length;
	}

	// The steam is like [size1][file1][size2][file2]...[sizeN][fileN].
	std::string ReadOneLine(FILE* stream, bool* eof) {
	DCHECK(stream != nullptr);
	DCHECK(eof != nullptr);

	int32_t length = ReadLineLength(stream, eof);
	if (length <= 0) {
	PLOG(ERROR) << "unexpected 0 length line.";
	*eof = true;
	return "";
	}

	std::string str(length, '\0');
	size_t count = fread(&str[0], sizeof(char), length, stream);
	if (feof(stream) \|\| ferror(stream) \|\| count != (uint32_t)length) {
	// error! :(
	PLOG(ERROR) << "unexpected end of the line during fread";
	*eof = true;
	return "";
	}
	return str;
	}

	static inline void LeftTrim(/inout/std::string& s) {
	s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
	return !std::isspace(ch);
	}));
	}

	// Parses an --output-format=ipc kind of line into an InodeResult.
	// Returns nullopt if parsing failed.
	std::optional<InodeResult> ParseFromLine(const std::string& line) {
	// inode <- INT:INT:INT
	// line_ok <- 'K ' inode ' ' STRING
	// line_err <- 'E ' inode ' ' INT
	//
	// result <- line_ok \| line_err

	std::stringstream ss{line};

	bool result_ok = false;

	std::string ok_or_error;
	ss >> ok_or_error;

	if (ss.fail()) {
	return std::nullopt;
	}

	if (ok_or_error == "K") {
	result_ok = true;
	} else if (ok_or_error == "E") {
	result_ok = false;
	} else {
	return std::nullopt;
	}

	std::string inode_s;
	ss >> inode_s;

	if (ss.fail()) {
	return std::nullopt;
	}

	Inode inode;

	std::string inode_parse_error_msg;
	if (!Inode::Parse(inode_s, /out/&inode, /out/&inode_parse_error_msg)) {
	return std::nullopt;
	}

	if (result_ok == false) {
	int error_code;
	ss >> error_code;

	if (ss.fail()) {
	return std::nullopt;
	}

	return InodeResult::makeFailure(inode, error_code);
	} else if (result_ok == true) {
	std::string rest_of_line;
	ss >> rest_of_line;

	// parse " string with potential spaces"
	// into "string with potential spaces"
	LeftTrim(/inout/rest_of_line);

	if (ss.fail()) {
	return std::nullopt;
	}

	const std::string& file_name = rest_of_line;

	return InodeResult::makeSuccess(inode, file_name);
	}

	return std::nullopt;
	}

	struct OutOfProcessInodeResolver::Impl {
	Impl() {
	}

	private:
	// Create the argv we will pass to the forked inode2filename, corresponds to #EmitAll.
	std::vector<std::string> CreateArgvAll(const InodeResolverDependencies& deps) const {
	std::vector<std::string> argv;
	argv.push_back("--all");

	return CreateArgv(deps, std::move(argv));
	}

	// Create the argv we will pass to the forked inode2filename, corresponds to
	// #FindFilenamesFromInodes.
	std::vector<std::string> CreateArgvFind(const InodeResolverDependencies& deps,
	const std::vector<Inode>& inodes) const {
	std::vector<std::string> argv;
	iorap::common::AppendArgsRepeatedly(argv, inodes);

	return CreateArgv(deps, std::move(argv));
	}

	std::vector<std::string> CreateArgv(const InodeResolverDependencies& deps,
	std::vector<std::string> append_argv) const {
	InodeResolverDependencies deps_oop = deps;
	deps_oop.process_mode = ProcessMode::kInProcessDirect;

	std::vector<std::string> argv = ToArgs(deps_oop);

	argv.push_back("--output-format=ipc");

	if (iorap::common::GetBoolEnvOrProperty("iorap.inode2filename.log.verbose", false)) {
	argv.push_back("--verbose");
	}

	iorap::common::AppendArgsRepeatedly(argv, std::move(append_argv));

	return argv;
	}

	public:
	// fork+exec into inode2filename with 'inodes' as the search list.
	// Each result is parsed into a dest#on_next(result).
	// If a fatal error occurs, dest#on_error is called once and no other callbacks are called.
	void EmitFromCommandFind(rxcpp::subscriber<InodeResult>& dest,
	const InodeResolverDependencies& deps,
	const std::vector<Inode>& inodes) {
	// Trivial case: complete immediately.
	// Executing inode2filename with empty search list will just print the --help menu.
	if (inodes.empty()) {
	dest.on_completed();
	}

	std::vector<std::string> argv = CreateArgvFind(deps, inodes);
	EmitFromCommandWithArgv(/inout/dest, std::move(argv), inodes.size());
	}

	// fork+exec into inode2filename with --all (listing all inodes).
	// Each result is parsed into a dest#on_next(result).
	// If a fatal error occurs, dest#on_error is called once and no other callbacks are called.
	void EmitFromCommandAll(rxcpp::subscriber<InodeResult>& dest,
	const InodeResolverDependencies& deps) {
	std::vector<std::string> argv = CreateArgvAll(deps);
	EmitFromCommandWithArgv(/inout/dest, std::move(argv), /result_count/std::nullopt);
	}

	private:
	void EmitFromCommandWithArgv(rxcpp::subscriber<InodeResult>& dest,
	std::vector<std::string> argv_vec,
	std::optional<size_t> result_count) {
	unique_fd pipe_reader, pipe_writer;
	if (!::android::base::Pipe(/out/&pipe_reader, /out/&pipe_writer)) {
	dest.on_error(
	rxcpp::util::make_error_ptr(
	IosBaseFailureWithErrno("Failed to create out-going pipe for inode2filename")));
	return;
	}

	pid_t child = fork();
	if (child == -1) {
	dest.on_error(
	rxcpp::util::make_error_ptr(
	IosBaseFailureWithErrno("Failed to fork process for inode2filename")));
	return;
	} else if (child > 0) { // we are the caller of this function
	LOG(DEBUG) << "forked into a process for inode2filename , pid = " << child;
	} else {
	// we are the child that was forked

	const char* kCommandFileName = GetCommandFileName();

	std::stringstream argv; // for debugging.
	for (std::string arg : argv_vec) {
	argv << arg << ' ';
	}
	LOG(DEBUG) << "fork+exec: " << kCommandFileName << " " << argv.str();

	// Redirect only stdout. stdin is unused, stderr is same as parent.
	if (dup2(pipe_writer.get(), STDOUT_FILENO) == -1) {
	// Trying to call #on_error does not make sense here because we are in a forked process,
	// the only thing we can do is crash definitively.
	PLOG(FATAL) << "Failed to dup2 for inode2filename";
	}

	std::unique_ptr<const char *[]> argv_ptr =
	common::VecToArgv(kCommandFileName, argv_vec);

	if (execve(kCommandFileName,
	(char **)argv_ptr.get(),
	/envp/nullptr) == -1) {
	// Trying to call #on_error does not make sense here because we are in a forked process,
	// the only thing we can do is crash definitively.
	PLOG(FATAL) << "Failed to execve process for inode2filename";
	}
	// This should never return.
	}

	// Immediately close the writer end of the pipe because we never use it.
	pipe_writer.reset();

	// Convert pipe(reader) file descriptor into FILE*.
	std::unique_ptr<FILE, int()(FILE)> file_reader{
	::android::base::Fdopen(std::move(pipe_reader), /mode/"r"), fclose};
	if (!file_reader) {
	dest.on_error(
	rxcpp::util::make_error_ptr(
	IosBaseFailureWithErrno("Failed to fdopen for inode2filename")));
	return;
	}

	size_t actual_result_count = 0;

	bool file_eof = false;
	while (!file_eof) {
	std::string inode2filename_line = ReadOneLine(file_reader.get(), /out/&file_eof);

	if (inode2filename_line.empty()) {
	if (!file_eof) {
	// Ignore empty lines.
	LOG(WARNING) << "inode2filename: got empty line";
	}
	continue;
	}

	LOG(DEBUG) << "inode2filename output-line: " << inode2filename_line;

	std::optional<InodeResult> res = ParseFromLine(inode2filename_line);
	if (!res) {
	std::string error_msg = "Invalid output: ";
	error_msg += inode2filename_line;
	dest.on_error(
	rxcpp::util::make_error_ptr(std::ios_base::failure(error_msg)));
	return;
	}
	dest.on_next(*res);

	++actual_result_count;
	}

	LOG(DEBUG) << "inode2filename output-eof";

	// Ensure that the # of inputs into the rx stream match the # of outputs.
	// This is validating the post-condition of FindFilenamesFromInodes.
	if (result_count && actual_result_count != *result_count) {
	std::stringstream ss;
	ss << "Invalid number of results, expected: " << *result_count;
	ss << ", actual: " << actual_result_count;

	dest.on_error(
	rxcpp::util::make_error_ptr(std::ios_base::failure(ss.str())));
	return;
	}

	CHECK(child > 0); // we are in the parent process, parse the IPC output of inode2filename
	dest.on_completed();
	}
	};

	rxcpp::observable<InodeResult>
	OutOfProcessInodeResolver::FindFilenamesFromInodes(std::vector<Inode> inodes) const {
	return rxcpp::observable<>::create<InodeResult>(
	[self=std::static_pointer_cast<const OutOfProcessInodeResolver>(shared_from_this()),
	inodes=std::move(inodes)](
	rxcpp::subscriber<InodeResult> s) {
	self->impl_->EmitFromCommandFind(s, self->GetDependencies(), inodes);
	});
	}

	rxcpp::observable<InodeResult>
	OutOfProcessInodeResolver::EmitAll() const {
	auto self = std::static_pointer_cast<const OutOfProcessInodeResolver>(shared_from_this());
	CHECK(self != nullptr);
	CHECK(self->impl_ != nullptr);

	return rxcpp::observable<>::create<InodeResult>(
	[self](rxcpp::subscriber<InodeResult> s) {
	CHECK(self != nullptr);
	CHECK(self->impl_ != nullptr);
	self->impl_->EmitFromCommandAll(s, self->GetDependencies());
	});
	}

	OutOfProcessInodeResolver::OutOfProcessInodeResolver(InodeResolverDependencies dependencies)
	: InodeResolver{std::move(dependencies)}, impl_{new Impl{}} {
	}

	OutOfProcessInodeResolver::~OutOfProcessInodeResolver() {
	// std::unique_ptr requires complete types, but we hide the definition in the header.
	delete impl_;
	}

	} // namespace iorap::inode2filename