Actually kill all run_cvd processes from cvd reset

It was failing to do so before because it was trying to extract more
information than just the pid from the process and giving up when it
couldn't. That extra information isn't needed to kill it.

Author: jemoreira

base/cvd/cuttlefish/common/libs/utils/files.cpp

@@ -450,6 +450,14 @@ off_t FileSize(const std::string& path) {
   return st.st_size;
 }
 
+Result<uid_t> FileOwner(const std::string& path) {
+  struct stat st{};
+  if (stat(path.c_str(), &st) == -1) {
+    return CF_ERRF("Failed to stat file '{}' : {}", path, StrError(errno));
+  }
+  return st.st_uid;
+}
+
 bool MakeFileExecutable(const std::string& path) {
   LOG(DEBUG) << "Making " << path << " executable";
   return chmod(path.c_str(), S_IRWXU) == 0;

base/cvd/cuttlefish/common/libs/utils/files.h

@@ -78,6 +78,7 @@ Result<std::chrono::system_clock::time_point> FileModificationTime(
     const std::string& path);
 // Whether a file exists and is a unix socket
 bool FileIsSocket(const std::string& path);
+Result<uid_t> FileOwner(const std::string& path);
 
 // acloud related API
 std::string FindImage(const std::string& search_path,

base/cvd/cuttlefish/host/commands/cvd/instances/BUILD.bazel

@@ -175,6 +175,7 @@ cf_cc_library(
     srcs = ["stop.cpp"],
     hdrs = ["stop.h"],
     deps = [
+        "//cuttlefish/common/libs/posix:strerror",
         "//cuttlefish/common/libs/utils:contains",
         "//cuttlefish/common/libs/utils:files",
         "//cuttlefish/common/libs/utils:proc_file_utils",

base/cvd/cuttlefish/host/commands/cvd/instances/run_cvd_proc_collector.cpp

@@ -236,4 +236,8 @@ Result<std::vector<GroupProcInfo>> CollectRunCvdGroups() {
   return collector.CfGroups();
 }
 
+Result<std::vector<pid_t>> CollectRunCvdProcesses() {
+  return CF_EXPECT(CollectPidsByExecName("run_cvd", getuid()));
+}
+
 }  // namespace cuttlefish

base/cvd/cuttlefish/host/commands/cvd/instances/run_cvd_proc_collector.h

@@ -51,4 +51,6 @@ struct GroupProcInfo {
 
 Result<std::vector<GroupProcInfo>> CollectRunCvdGroups();
 
+Result<std::vector<pid_t>> CollectRunCvdProcesses();
+
 }  // namespace cuttlefish

base/cvd/cuttlefish/host/commands/cvd/instances/stop.cpp

@@ -16,7 +16,10 @@
 
 #include "cuttlefish/host/commands/cvd/instances/stop.h"
 
+#include <errno.h>
 #include <signal.h>
+#include <string.h>
+#include <unistd.h>
 
 #include <iostream>  // std::endl
 #include <sstream>
@@ -30,6 +33,7 @@
 #include <fmt/core.h>
 #include <fmt/ranges.h>  // NOLINT(misc-include-cleaner): version difference
 
+#include "cuttlefish/common/libs/posix/strerror.h"
 #include "cuttlefish/common/libs/utils/contains.h"
 #include "cuttlefish/common/libs/utils/files.h"
 #include "cuttlefish/common/libs/utils/proc_file_utils.h"
@@ -110,6 +114,12 @@ static bool IsStillRunCvd(const pid_t pid) {
           "run_cvd");
 }
 
+Result<void> SendSignal(pid_t pid) {
+  int kill_res = kill(pid, SIGKILL);
+  CF_EXPECTF(kill_res == 0, "Failed to kill {}: {}", pid, StrError(errno));
+  return {};
+}
+
 Result<void> SendSignal(const GroupProcInfo& group_info) {
   std::vector<pid_t> failed_pids;
   for (const auto& [unused, instance] : group_info.instances_) {
@@ -118,7 +128,7 @@ Result<void> SendSignal(const GroupProcInfo& group_info) {
         continue;
       }
       LOG(INFO) << "Sending SIGKILL to process " << parent_run_cvd_pid;
-      if (kill(parent_run_cvd_pid, SIGKILL) == 0) {
+      if (SendSignal(parent_run_cvd_pid).ok()) {
         LOG(VERBOSE) << "Successfully SIGKILL'ed " << parent_run_cvd_pid;
       } else {
         failed_pids.push_back(parent_run_cvd_pid);
@@ -170,25 +180,58 @@ Result<void> ForcefullyStopGroup(const GroupProcInfo& group) {
   return {};
 }
 
+Result<void> KillAllRunCvds() {
+  auto run_cvd_pids = CF_EXPECT(CollectRunCvdProcesses());
+  if (run_cvd_pids.empty()) {
+    return {};
+  }
+  LOG(INFO) << run_cvd_pids.size()
+               << " run_cvd processes still remain, will stop forcefully";
+  for (pid_t group_pid : run_cvd_pids) {
+    if (Result<void> result = SendSignal(group_pid); !result.ok()) {
+      LOG(ERROR) << result.error().FormatForEnv();
+    }
+  }
+  return {};
+}
+
+Result<void> DeleteAllOwnedInstanceLocks() {
+  const std::string lock_dir = InstanceLocksPath();
+  uid_t own_uid = geteuid();
+  for (const std::string& lock_file: CF_EXPECT(DirectoryContents(lock_dir))) {
+    std::string lock_file_path = fmt::format("{}/{}", lock_dir, lock_file);
+    Result<uid_t> file_uid_res = FileOwner(lock_file_path);
+    if (!file_uid_res.ok()) {
+      LOG(ERROR) << "Failed to obtain owner of '" << lock_file_path << "'";
+      continue;
+    }
+    if (*file_uid_res != own_uid) {
+      LOG(VERBOSE) << "Skipped '" << lock_file_path
+                   << "' because it's not owned by current user";
+      continue;
+    }
+    if (!RemoveFile(lock_file_path)) {
+      LOG(ERROR) << "Failed to remove '" << lock_file_path << "'";
+    }
+  }
+  return {};
+}
+
 }  // namespace
 
 Result<void> KillAllCuttlefishInstances(bool clear_runtime_dirs) {
-  auto stop_cvd_result = RunStopCvdAll(clear_runtime_dirs);
-  if (!stop_cvd_result.ok()) {
-    LOG(ERROR) << stop_cvd_result.error().FormatForEnv();
+  if (Result<void> res = RunStopCvdAll(clear_runtime_dirs); !res.ok()) {
+    LOG(ERROR) << res.error().FormatForEnv();
   }
-  std::vector<GroupProcInfo> group_infos = CF_EXPECT(CollectRunCvdGroups());
-  if (group_infos.empty()) {
-    return {};
+
+  if (Result<void> res = KillAllRunCvds(); !res.ok()) {
+    LOG(ERROR) << res.error().FormatForEnv();
   }
-  LOG(INFO) << group_infos.size()
-               << " instance groups still remain, will stop forcefully";
-  for (const GroupProcInfo& group_info : group_infos) {
-    auto result = ForcefullyStopGroup(group_info);
-    if (!result.ok()) {
-      LOG(ERROR) << result.error().FormatForEnv();
-    }
+
+  if (Result<void> res = DeleteAllOwnedInstanceLocks(); !res.ok()) {
+    LOG(ERROR) << res.error().FormatForEnv();
   }
+
   return {};
 }