Refactor user/group name resolving code

[labath]

Summary

This creates an abstract base class called "UserIDResolver", which can
be implemented to provide user/group ID resolution capabilities for
various objects. Posix host implement a PosixUserIDResolver, which does
that using posix apis (getpwuid and friends). PlatformGDBRemote
forwards queries over the gdb-remote link, etc. ProcessInstanceInfo
class is refactored to make use of this interface instead of taking a
platform pointer as an argument. The base resolver class already
implements caching and thread-safety, so implementations don't have to
worry about that.

The main motivating factor for this was to remove external dependencies
from the ProcessInstanceInfo class (so it can be put next to
ProcessLaunchInfo and friends), but it has other benefits too:

• ability to test the user name caching code
• ability to test ProcessInstanceInfo dumping code
• consistent interface for user/group resolution between Platform and Host classes.

[jingham]

You are using a mix of llvm & lldb naming conventions for local variables and arguments and the ivars of UserIDResolver (lots of "Uid", etc...) Probably better to stick with the lldb convention.

Other than that it looks good to me.

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

439–440

Do we need auto here? Since we have a bunch of API's returning StringRef's now when I see strings returned I get paranoid about their lifespan. auto hides the fact that I don't need to worry...

[clayborg]

include/lldb/Host/UserIDResolver.h

24 ↗

(On Diff #186601)

make this 64 bit for future proofing? And if so, just use lldb::user_id_t?

27 ↗

(On Diff #186601)

If we are storing this as an optional std::string, why hand it out as a StringRef?

49–51 ↗

(On Diff #186601)

prefix with "m_", make lower case and separate by "_"

source/Commands/CommandObjectPlatform.cpp

1154

Why are we not passing the platform in still? What if we need it for something else?

1156

Ditto

source/Host/CMakeLists.txt

23 ↗

(On Diff #186601)

remove whitespace change unless it is needed?

37 ↗

(On Diff #186601)

remove whitespace change unless it is needed?

45 ↗

(On Diff #186601)

remove whitespace change unless it is needed?

source/Target/Process.cpp

281

So we are currently only using the platform for the user ID resolving, but it might be nice to keep the platform as the argument in case we need it for something else in the future?

352

Ditto

[labath]

I didn't get around to address the style issues yet, but I wanted to respond to one high-level comment today:

So we are currently only using the platform for the user ID resolving, but it might be nice to keep the platform as the argument in case we need it for something else in the future?

Doing this would defeat the purpose of this patch, as the ProcessInstanceInfo class would no longer be standalone. I don't think it's very likely that we'll need other platform capabilities to decode this class, but in case we do, I see two options:

• hide the details of this new thing behind an interface. This could either be a new interface, or an extension of the user id resolver interface, depending on what the thing is.
• Move the Dumping code out of the ProcessInstanceInfo class. If interpreting the ProcessInstanceInfo data is so complicated that we need access to full platform class, then I don't think the ProcessInstanceInfo is the right place for that code. In this case, we could move the code to the platform class (platform->Dump(stream, info)), or a completely separate class altogether (like we did with the DumpDataExtractor classes).

[labath]

Rename things to follow lldb style. All the remaining comments should be either
marked as done, or have a comment explaining why I don't think doing that is a
good idea.

include/lldb/Host/UserIDResolver.h

24 ↗

(On Diff #186601)

I think the best way to future-proof things is to use a separate type for logically distinct entities. While user_id_t sounds like it would be the right type, it is actually used for a completely different purpose.

And while I don't fully understand how windows user id's work, they seem to be represented as strings of the form "S-1-5-21-7375663-6890924511-1272660413-2944159". If that's the thing we're going to use on windows, then even 64 bits will not be enough, and we may have to use something different altogether.

I used 32-bits for now, because that's what it was used until now, and it seemed to be enough. There are also some latent uses of UINT32_MAX for invalid uids, which would need to be tracked down to change that.

27 ↗

(On Diff #186601)

I am storing it as std::string, as I need it to provide storage, but generally, I think the public APIs should use StringRefs for non-owning string references. I could hand this out as const llvm::Optional<std::string> &, but that would be even longer to type, and would increase the chance of someone doing an unintentional string copy.

source/Host/CMakeLists.txt

23 ↗

(On Diff #186601)

I've committed the sorting as a separate patch.

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

439–440

I've removed the auto, though I am not sure if that alleviates your fears, as the returned type is StringRef. There is still nothing to worry about though, as the backing storage is held by the resolver object.

[jingham]

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

439–440

So how do I reason about the lifespan of this StringRef, then? Now I have to know that GetUserIDResolver doesn't make a temporary UserIDResolver, but a reference to one that persists - for how long again?

[labath]

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

439–440

Yes, that would be line of reasoning I envisioned. The returned resolver (and, transitively, the storage backing the StringRef) ought to exist at least while the "HostInfo" class is valid, so from HostInfo::Initialize() and until HostInfo::Finalize(). In practice it will be even longer because the resolver is constructed lazily on first use, and will be destroyed only by llvm_shutdown (which we don't call ever), but that's not what I would promise. For the "platform" version of the GetUserIDResolver function, the resolver ought to exist for as long as the platform instance you got it from is alive.

I can put this into the method comments, but it seems pretty straigh-forward to me (e.g. I would expect this comment to apply to all HostInfo functions. I definitely know that HostInfo::GetArchitecture blows up if called before Initialize()).

[zturner]

include/lldb/Host/UserIDResolver.h

9 ↗

(On Diff #186982)

I wonder if this class should actually be in Host. While some specific implementation of it might be host-dependent, the interface itself is not. I kind of envision at some point in the future having a target that contains all of our core interfaces that someone can include and re-implement small pieces of the debugger without having to bring in the entire thing. This is also nice from a mocking / unittesting perspective.

So I think this would be better if it were in Utility (or some other top-level library such as Interfaces)

[labath]

include/lldb/Host/UserIDResolver.h

9 ↗

(On Diff #186982)

Yes, I've wondered about that too. I went with Host because that was enough to make things work, but I certainly see the case for this being Utility too. I'll move it there.

[labath]

Move the resolver interface into Utility

[jingham]

This is fine by me, though Greg I think still had an outstanding question. If he's satisfied, I am.

[labath]

Greg, I believe I've responded to all your comments. If there is anything else you want me to do here, please let me know.

include/lldb/Host/HostInfoBase.h

 //===-- HostInfoBase.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_Host_HostInfoBase_h_
 #define lldb_Host_HostInfoBase_h_
 
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/UserIDResolver.h"
 #include "lldb/lldb-enumerations.h"
-
 #include "llvm/ADT/StringRef.h"
 
 #include <stdint.h>
 
 #include <string>
 
 namespace lldb_private {
 
public:
 
   //---------------------------------------------------------------------------
   /// If the triple does not specify the vendor, os, and environment parts, we
   /// "augment" these using information from the host and return the resulting
   /// ArchSpec object.
   //---------------------------------------------------------------------------
   static ArchSpec GetAugmentedArchSpec(llvm::StringRef triple);
 
+  static UserIDResolver &GetUserIDResolver();
+
 protected:
   static bool ComputeSharedLibraryDirectory(FileSpec &file_spec);
   static bool ComputeSupportExeDirectory(FileSpec &file_spec);
   static bool ComputeProcessTempFileDirectory(FileSpec &file_spec);
   static bool ComputeGlobalTempFileDirectory(FileSpec &file_spec);
   static bool ComputeTempFileBaseDirectory(FileSpec &file_spec);
   static bool ComputeHeaderDirectory(FileSpec &file_spec);
   static bool ComputeSystemPluginsDirectory(FileSpec &file_spec);
   static bool ComputeUserPluginsDirectory(FileSpec &file_spec);
 
   static void ComputeHostArchitectureSupport(ArchSpec &arch_32,
                                              ArchSpec &arch_64);
 };
 }
 
 #endif

include/lldb/Host/posix/HostInfoPosix.h

 namespace lldb_private {
 
 class HostInfoPosix : public HostInfoBase {
   friend class HostInfoBase;
 
 public:
   static size_t GetPageSize();
   static bool GetHostname(std::string &s);
-  static const char *LookupUserName(uint32_t uid, std::string &user_name);
-  static const char *LookupGroupName(uint32_t gid, std::string &group_name);
+  static UserIDResolver &GetUserIDResolver();
 
   static uint32_t GetUserID();
   static uint32_t GetGroupID();
   static uint32_t GetEffectiveUserID();
   static uint32_t GetEffectiveGroupID();
 
   static FileSpec GetDefaultShell();
 

include/lldb/Target/Platform.h

 
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Timeout.h"
+#include "lldb/Utility/UserIDResolver.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-public.h"
 #include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
 class ModuleCache;
 enum MmapFlags { eMmapFlagsPrivate = 1, eMmapFlagsAnon = 2 };
public:
   virtual ArchSpec GetRemoteSystemArchitecture() {
     return ArchSpec(); // Return an invalid architecture
   }
 
   virtual FileSpec GetRemoteWorkingDirectory() { return m_working_dir; }
 
   virtual bool SetRemoteWorkingDirectory(const FileSpec &working_dir);
 
-  virtual const char *GetUserName(uint32_t uid);
-
-  virtual const char *GetGroupName(uint32_t gid);
+  virtual UserIDResolver &GetUserIDResolver() = 0;
 
   //------------------------------------------------------------------
   /// Locate a file for a platform.
   ///
   /// The default implementation of this function will return the same file
   /// patch in \a local_file as was in \a platform_file.
   ///
   /// @param[in] platform_file
protected:
   std::string m_name;
   llvm::VersionTuple m_os_version;
   ArchSpec
       m_system_arch; // The architecture of the kernel or the remote platform
   typedef std::map<uint32_t, ConstString> IDToNameMap;
   // Mutex for modifying Platform data structures that should only be used for
   // non-reentrant code
   std::mutex m_mutex;
-  IDToNameMap m_uid_map;
-  IDToNameMap m_gid_map;
   size_t m_max_uid_name_len;
   size_t m_max_gid_name_len;
   bool m_supports_rsync;
   std::string m_rsync_opts;
   std::string m_rsync_prefix;
   bool m_supports_ssh;
   std::string m_ssh_opts;
   bool m_ignores_remote_hostname;
protected:
   /// are different.
   ///
   /// The base class Platform ivar m_trap_handlers should be updated by the
   /// Platform subclass when this method is called.  If there are no
   /// predefined trap handlers, this method may be a no-op.
   //------------------------------------------------------------------
   virtual void CalculateTrapHandlerSymbolNames() = 0;
 
-  const char *GetCachedUserName(uint32_t uid) {
-    std::lock_guard<std::mutex> guard(m_mutex);
-    // return the empty string if our string is NULL so we can tell when things
-    // were in the negative cached (didn't find a valid user name, don't keep
-    // trying)
-    const auto pos = m_uid_map.find(uid);
-    return ((pos != m_uid_map.end()) ? pos->second.AsCString("") : nullptr);
-  }
-
-  const char *SetCachedUserName(uint32_t uid, const char *name,
-                                size_t name_len) {
-    std::lock_guard<std::mutex> guard(m_mutex);
-    ConstString const_name(name);
-    m_uid_map[uid] = const_name;
-    if (m_max_uid_name_len < name_len)
-      m_max_uid_name_len = name_len;
-    // Const strings lives forever in our const string pool, so we can return
-    // the const char *
-    return const_name.GetCString();
-  }
-
-  void SetUserNameNotFound(uint32_t uid) {
-    std::lock_guard<std::mutex> guard(m_mutex);
-    m_uid_map[uid] = ConstString();
-  }
-
-  void ClearCachedUserNames() {
-    std::lock_guard<std::mutex> guard(m_mutex);
-    m_uid_map.clear();
-  }
-
-  const char *GetCachedGroupName(uint32_t gid) {
-    std::lock_guard<std::mutex> guard(m_mutex);
-    // return the empty string if our string is NULL so we can tell when things
-    // were in the negative cached (didn't find a valid group name, don't keep
-    // trying)
-    const auto pos = m_gid_map.find(gid);
-    return ((pos != m_gid_map.end()) ? pos->second.AsCString("") : nullptr);
-  }
-
-  const char *SetCachedGroupName(uint32_t gid, const char *name,
-                                 size_t name_len) {
-    std::lock_guard<std::mutex> guard(m_mutex);
-    ConstString const_name(name);
-    m_gid_map[gid] = const_name;
-    if (m_max_gid_name_len < name_len)
-      m_max_gid_name_len = name_len;
-    // Const strings lives forever in our const string pool, so we can return
-    // the const char *
-    return const_name.GetCString();
-  }
-
-  void SetGroupNameNotFound(uint32_t gid) {
-    std::lock_guard<std::mutex> guard(m_mutex);
-    m_gid_map[gid] = ConstString();
-  }
-
-  void ClearCachedGroupNames() {
-    std::lock_guard<std::mutex> guard(m_mutex);
-    m_gid_map.clear();
-  }
-
   Status GetCachedExecutable(ModuleSpec &module_spec, lldb::ModuleSP &module_sp,
                              const FileSpecList *module_search_paths_ptr,
                              Platform &remote_platform);
 
   virtual Status DownloadModuleSlice(const FileSpec &src_file_spec,
                                      const uint64_t src_offset,
                                      const uint64_t src_size,
                                      const FileSpec &dst_file_spec);

include/lldb/Target/Process.h

 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/Listener.h"
 #include "lldb/Utility/NameMatches.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/TraceOptions.h"
+#include "lldb/Utility/UserIDResolver.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
 template <typename B, typename S> struct Range;
public:
   lldb::pid_t GetParentProcessID() const { return m_parent_pid; }
 
   void SetParentProcessID(lldb::pid_t pid) { m_parent_pid = pid; }
 
   bool ParentProcessIDIsValid() const {
     return m_parent_pid != LLDB_INVALID_PROCESS_ID;
   }
 
-  void Dump(Stream &s, Platform *platform) const;
+  void Dump(Stream &s, UserIDResolver &resolver) const;
 
-  static void DumpTableHeader(Stream &s, Platform *platform, bool show_args,
-                              bool verbose);
+  static void DumpTableHeader(Stream &s, bool show_args, bool verbose);
 
-  void DumpAsTableRow(Stream &s, Platform *platform, bool show_args,
+  void DumpAsTableRow(Stream &s, UserIDResolver &resolver, bool show_args,
                       bool verbose) const;
 
 protected:
   uint32_t m_euid;
   uint32_t m_egid;
   lldb::pid_t m_parent_pid;
 };
 

include/lldb/Target/RemoteAwarePlatform.h

public:
   ArchSpec GetRemoteSystemArchitecture() override;
 
   Status RunShellCommand(const char *command, const FileSpec &working_dir,
                          int *status_ptr, int *signo_ptr,
                          std::string *command_output,
                          const Timeout<std::micro> &timeout) override;
 
   const char *GetHostname() override;
-  const char *GetUserName(uint32_t uid) override;
-  const char *GetGroupName(uint32_t gid) override;
+  UserIDResolver &GetUserIDResolver() override;
   lldb_private::Environment GetEnvironment() override;
 
   bool IsConnected() const override;
 
   bool GetProcessInfo(lldb::pid_t pid, ProcessInstanceInfo &proc_info) override;
   uint32_t FindProcesses(const ProcessInstanceInfoMatch &match_info,
                          ProcessInstanceInfoList &process_infos) override;
 

include/lldb/Utility/UserIDResolver.h

+//===-- UserIDResolver.h ----------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_UTILITY_USERIDRESOLVER_H
+#define LLDB_UTILITY_USERIDRESOLVER_H
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/StringRef.h"
+#include <mutex>
+
+namespace lldb_private {
+
+/// An abstract interface for things that know how to map numeric user/group IDs
+/// into names. It caches the resolved names to avoid repeating expensive
+/// queries. The cache is internally protected by a mutex, so concurrent queries
+/// are safe.
+class UserIDResolver {
+public:
+  typedef uint32_t id_t;
+  virtual ~UserIDResolver(); // anchor
+
+  llvm::Optional<llvm::StringRef> GetUserName(id_t uid) {
+    return Get(uid, m_uid_cache, &UserIDResolver::DoGetUserName);
+  }
+  llvm::Optional<llvm::StringRef> GetGroupName(id_t gid) {
+    return Get(gid, m_gid_cache, &UserIDResolver::DoGetGroupName);
+  }
+
+  /// Returns a resolver which returns a failure value for each query. Useful as
+  /// a fallback value for the case when we know all lookups will fail.
+  static UserIDResolver &GetNoopResolver();
+
+protected:
+  virtual llvm::Optional<std::string> DoGetUserName(id_t uid) = 0;
+  virtual llvm::Optional<std::string> DoGetGroupName(id_t gid) = 0;
+
+private:
+  using Map = llvm::DenseMap<id_t, llvm::Optional<std::string>>;
+
+  llvm::Optional<llvm::StringRef>
+  Get(id_t id, Map &cache,
+      llvm::Optional<std::string> (UserIDResolver::*do_get)(id_t));
+
+  std::mutex m_mutex;
+  Map m_uid_cache;
+  Map m_gid_cache;
+};
+
+} // namespace lldb_private
+
+#endif // #ifndef LLDB_HOST_USERIDRESOLVER_H

source/Commands/CommandObjectPlatform.cpp

if (platform_sp) {
         if (platform_sp) {
           Stream &ostrm = result.GetOutputStream();
 
           lldb::pid_t pid =
               m_options.match_info.GetProcessInfo().GetProcessID();
           if (pid != LLDB_INVALID_PROCESS_ID) {
             ProcessInstanceInfo proc_info;
             if (platform_sp->GetProcessInfo(pid, proc_info)) {
-              ProcessInstanceInfo::DumpTableHeader(ostrm, platform_sp.get(),
-                                                   m_options.show_args,
+              ProcessInstanceInfo::DumpTableHeader(ostrm, m_options.show_args,
                                                    m_options.verbose);
-              proc_info.DumpAsTableRow(ostrm, platform_sp.get(),
+              proc_info.DumpAsTableRow(ostrm, platform_sp->GetUserIDResolver(),
                                        m_options.show_args, m_options.verbose);
               result.SetStatus(eReturnStatusSuccessFinishResult);
             } else {
               result.AppendErrorWithFormat(
                   "no process found with pid = %" PRIu64 "\n", pid);
               result.SetStatus(eReturnStatusFailed);
             }
           } else {
if (platform_sp) {
               result.AppendMessageWithFormat(
                   "%u matching process%s found on \"%s\"", matches,
                   matches > 1 ? "es were" : " was",
                   platform_sp->GetName().GetCString());
               if (match_desc)
                 result.AppendMessageWithFormat(" whose name %s \"%s\"",
                                                match_desc, match_name);
               result.AppendMessageWithFormat("\n");
-              ProcessInstanceInfo::DumpTableHeader(ostrm, platform_sp.get(),
-                                                   m_options.show_args,
+              ProcessInstanceInfo::DumpTableHeader(ostrm, m_options.show_args,
                                                    m_options.verbose);
               for (uint32_t i = 0; i < matches; ++i) {
                 proc_infos.GetProcessInfoAtIndex(i).DumpAsTableRow(
-                    ostrm, platform_sp.get(), m_options.show_args,
-                    m_options.verbose);
+                    ostrm, platform_sp->GetUserIDResolver(),
+                    m_options.show_args, m_options.verbose);
               }
             }
           }
         }
       } else {
         result.AppendError("invalid args: process list takes only options\n");
         result.SetStatus(eReturnStatusFailed);
       }
if (platform_sp) {
                                            entry.ref.str().c_str());
               result.SetStatus(eReturnStatusFailed);
               break;
             } else {
               ProcessInstanceInfo proc_info;
               if (platform_sp->GetProcessInfo(pid, proc_info)) {
                 ostrm.Printf("Process information for process %" PRIu64 ":\n",
                              pid);
-                proc_info.Dump(ostrm, platform_sp.get());
+                proc_info.Dump(ostrm, platform_sp->GetUserIDResolver());
               } else {
                 ostrm.Printf("error: no process information is available for "
                              "process %" PRIu64 "\n",
                              pid);
               }
               ostrm.EOL();
             }
           }

source/Host/posix/HostInfoPosix.cpp

 
 #ifdef __ANDROID__
 #include <android/api-level.h>
 #endif
 #if defined(__ANDROID_API__) && __ANDROID_API__ < 21
 #define USE_GETPWUID
 #endif
 
-#ifdef USE_GETPWUID
-static std::mutex s_getpwuid_lock;
-#endif
+namespace {
+class PosixUserIDResolver : public UserIDResolver {
+protected:
+  llvm::Optional<std::string> DoGetUserName(id_t uid) override;
+  llvm::Optional<std::string> DoGetGroupName(id_t gid) override;
+};
+} // namespace
 
-const char *HostInfoPosix::LookupUserName(uint32_t uid,
-                                          std::string &user_name) {
+llvm::Optional<std::string> PosixUserIDResolver::DoGetUserName(id_t uid) {
 #ifdef USE_GETPWUID
   // getpwuid_r is missing from android-9
-  // make getpwuid thread safe with a mutex
-  std::lock_guard<std::mutex> lock(s_getpwuid_lock);
+  // UserIDResolver provides some thread safety by making sure noone calls this
+  // function concurrently, but using getpwuid is ultimately not thread-safe as
+  // we don't know who else might be calling it.
   struct passwd *user_info_ptr = ::getpwuid(uid);
-  if (user_info_ptr) {
-    user_name.assign(user_info_ptr->pw_name);
-    return user_name.c_str();
-  }
+  if (user_info_ptr)
+    return std::string(user_info_ptr->pw_name);
 #else
   struct passwd user_info;
   struct passwd *user_info_ptr = &user_info;
   char user_buffer[PATH_MAX];
   size_t user_buffer_size = sizeof(user_buffer);
   if (::getpwuid_r(uid, &user_info, user_buffer, user_buffer_size,
-                   &user_info_ptr) == 0) {
-    if (user_info_ptr) {
-      user_name.assign(user_info_ptr->pw_name);
-      return user_name.c_str();
-    }
+                   &user_info_ptr) == 0 &&
+      user_info_ptr) {
+    return std::string(user_info_ptr->pw_name);
   }
 #endif
-  user_name.clear();
-  return nullptr;
+  return llvm::None;
 }
 
-const char *HostInfoPosix::LookupGroupName(uint32_t gid,
-                                           std::string &group_name) {
+llvm::Optional<std::string> PosixUserIDResolver::DoGetGroupName(id_t gid) {
 #ifndef __ANDROID__
   char group_buffer[PATH_MAX];
   size_t group_buffer_size = sizeof(group_buffer);
   struct group group_info;
   struct group *group_info_ptr = &group_info;
   // Try the threadsafe version first
   if (::getgrgid_r(gid, &group_info, group_buffer, group_buffer_size,
                    &group_info_ptr) == 0) {
-    if (group_info_ptr) {
-      group_name.assign(group_info_ptr->gr_name);
-      return group_name.c_str();
-    }
+    if (group_info_ptr)
+      return std::string(group_info_ptr->gr_name);
   } else {
     // The threadsafe version isn't currently working for me on darwin, but the
     // non-threadsafe version is, so I am calling it below.
     group_info_ptr = ::getgrgid(gid);
-    if (group_info_ptr) {
-      group_name.assign(group_info_ptr->gr_name);
-      return group_name.c_str();
-    }
-  }
-  group_name.clear();
+    if (group_info_ptr)
+      return std::string(group_info_ptr->gr_name);
 #else
   assert(false && "getgrgid_r() not supported on Android");
 #endif
-  return NULL;
+  return llvm::None;
+}
+
+static llvm::ManagedStatic<PosixUserIDResolver> g_user_id_resolver;
+
+UserIDResolver &HostInfoPosix::GetUserIDResolver() {
+  return *g_user_id_resolver;
 }
 
 uint32_t HostInfoPosix::GetUserID() { return getuid(); }
 
 uint32_t HostInfoPosix::GetGroupID() { return getgid(); }
 
 uint32_t HostInfoPosix::GetEffectiveUserID() { return geteuid(); }
 

source/Plugins/Platform/Kalimba/PlatformKalimba.h

public:
   lldb::ProcessSP Attach(ProcessAttachInfo &attach_info, Debugger &debugger,
                          Target *target, Status &error) override;
 
   // Kalimba processes can not be launched by spawning and attaching.
   bool CanDebugProcess() override { return false; }
 
   void CalculateTrapHandlerSymbolNames() override;
 
+  UserIDResolver &GetUserIDResolver() override {
+    return UserIDResolver::GetNoopResolver();
+  }
+
 protected:
   lldb::PlatformSP m_remote_platform_sp;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(PlatformKalimba);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_PlatformKalimba_h_

source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h

 
 #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h"
 #include "Plugins/Process/Utility/GDBRemoteSignals.h"
 #include "lldb/Target/Platform.h"
 
 namespace lldb_private {
 namespace platform_gdb_server {
 
-class PlatformRemoteGDBServer : public Platform {
+class PlatformRemoteGDBServer : public Platform, private UserIDResolver {
 public:
   static void Initialize();
 
   static void Terminate();
 
   static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
 
   static ConstString GetPluginNameStatic();
public:
   FileSpec GetRemoteWorkingDirectory() override;
 
   bool SetRemoteWorkingDirectory(const FileSpec &working_dir) override;
 
   // Remote subclasses should override this and return a valid instance
   // name if connected.
   const char *GetHostname() override;
 
-  const char *GetUserName(uint32_t uid) override;
-
-  const char *GetGroupName(uint32_t gid) override;
+  UserIDResolver &GetUserIDResolver() override { return *this; }
 
   bool IsConnected() const override;
 
   Status ConnectRemote(Args &args) override;
 
   Status DisconnectRemote() override;
 
   Status MakeDirectory(const FileSpec &file_spec,
protected:
   virtual std::string MakeUrl(const char *scheme, const char *hostname,
                               uint16_t port, const char *path);
 
 private:
   std::string MakeGdbServerUrl(const std::string &platform_scheme,
                                const std::string &platform_hostname,
                                uint16_t port, const char *socket_name);
 
+  llvm::Optional<std::string> DoGetUserName(UserIDResolver::id_t uid) override;
+  llvm::Optional<std::string> DoGetGroupName(UserIDResolver::id_t uid) override;
+
   DISALLOW_COPY_AND_ASSIGN(PlatformRemoteGDBServer);
 };
 
 } // namespace platform_gdb_server
 } // namespace lldb_private
 
 #endif // liblldb_PlatformRemoteGDBServer_h_

source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

 
 const char *PlatformRemoteGDBServer::GetHostname() {
   m_gdb_client.GetHostname(m_name);
   if (m_name.empty())
     return NULL;
   return m_name.c_str();
 }
 
-const char *PlatformRemoteGDBServer::GetUserName(uint32_t uid) {
-  // Try and get a cache user name first
-  const char *cached_user_name = Platform::GetUserName(uid);
-  if (cached_user_name)
-    return cached_user_name;
+llvm::Optional<std::string>
+PlatformRemoteGDBServer::DoGetUserName(UserIDResolver::id_t uid) {
   std::string name;
   if (m_gdb_client.GetUserName(uid, name))
-    return SetCachedUserName(uid, name.c_str(), name.size());
-
-  SetUserNameNotFound(uid); // Negative cache so we don't keep sending packets
-  return NULL;
+    return std::move(name);
+  return llvm::None;
 }
 
-const char *PlatformRemoteGDBServer::GetGroupName(uint32_t gid) {
-  const char *cached_group_name = Platform::GetGroupName(gid);
-  if (cached_group_name)
-    return cached_group_name;
+llvm::Optional<std::string>
+PlatformRemoteGDBServer::DoGetGroupName(UserIDResolver::id_t gid) {
   std::string name;
   if (m_gdb_client.GetGroupName(gid, name))
-    return SetCachedGroupName(gid, name.c_str(), name.size());
-
-  SetGroupNameNotFound(gid); // Negative cache so we don't keep sending packets
-  return NULL;
+    return std::move(name);
+  return llvm::None;
 }
 
 uint32_t PlatformRemoteGDBServer::FindProcesses(
     const ProcessInstanceInfoMatch &match_info,
     ProcessInstanceInfoList &process_infos) {
   return m_gdb_client.FindProcesses(match_info, process_infos);
 }
 

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

#if !defined(LLDB_DISABLE_POSIX)
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
   if (log)
     log->Printf("GDBRemoteCommunicationServerCommon::%s begin", __FUNCTION__);
 
   // Packet format: "qUserName:%i" where %i is the uid
   packet.SetFilePos(::strlen("qUserName:"));
   uint32_t uid = packet.GetU32(UINT32_MAX);
   if (uid != UINT32_MAX) {
-    std::string name;
-    if (HostInfo::LookupUserName(uid, name)) {
+    if (llvm::Optional<llvm::StringRef> name =
+            HostInfo::GetUserIDResolver().GetUserName(uid)) {
       StreamString response;
-      response.PutStringAsRawHex8(name);
+      response.PutStringAsRawHex8(*name);
       return SendPacketNoLock(response.GetString());
     }
   }
   if (log)
     log->Printf("GDBRemoteCommunicationServerCommon::%s end", __FUNCTION__);
 #endif
   return SendErrorResponse(5);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_qGroupName(
     StringExtractorGDBRemote &packet) {
 #if !defined(LLDB_DISABLE_POSIX)
   // Packet format: "qGroupName:%i" where %i is the gid
   packet.SetFilePos(::strlen("qGroupName:"));
   uint32_t gid = packet.GetU32(UINT32_MAX);
   if (gid != UINT32_MAX) {
-    std::string name;
-    if (HostInfo::LookupGroupName(gid, name)) {
+    if (llvm::Optional<llvm::StringRef> name =
+            HostInfo::GetUserIDResolver().GetGroupName(gid)) {
       StreamString response;
-      response.PutStringAsRawHex8(name);
+      response.PutStringAsRawHex8(*name);
       return SendPacketNoLock(response.GetString());
     }
   }
 #endif
   return SendErrorResponse(6);
 }
 
 GDBRemoteCommunication::PacketResult

source/Target/Platform.cpp

 
 //------------------------------------------------------------------
 /// Default Constructor
 //------------------------------------------------------------------
 Platform::Platform(bool is_host)
     : m_is_host(is_host), m_os_version_set_while_connected(false),
       m_system_arch_set_while_connected(false), m_sdk_sysroot(), m_sdk_build(),
       m_working_dir(), m_remote_url(), m_name(), m_system_arch(), m_mutex(),
-      m_uid_map(), m_gid_map(), m_max_uid_name_len(0), m_max_gid_name_len(0),
-      m_supports_rsync(false), m_rsync_opts(), m_rsync_prefix(),
-      m_supports_ssh(false), m_ssh_opts(), m_ignores_remote_hostname(false),
-      m_trap_handlers(), m_calculated_trap_handlers(false),
+      m_max_uid_name_len(0), m_max_gid_name_len(0), m_supports_rsync(false),
+      m_rsync_opts(), m_rsync_prefix(), m_supports_ssh(false), m_ssh_opts(),
+      m_ignores_remote_hostname(false), m_trap_handlers(),
+      m_calculated_trap_handlers(false),
       m_module_cache(llvm::make_unique<ModuleCache>()) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
   if (log)
     log->Printf("%p Platform::Platform()", static_cast<void *>(this));
 }
 
 //------------------------------------------------------------------
 /// Destructor.
bool Platform::SetRemoteWorkingDirectory(const FileSpec &working_dir) {
   Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
   if (log)
     log->Printf("Platform::SetRemoteWorkingDirectory('%s')",
                 working_dir.GetCString());
   m_working_dir = working_dir;
   return true;
 }
 
-const char *Platform::GetUserName(uint32_t uid) {
-#if !defined(LLDB_DISABLE_POSIX)
-  const char *user_name = GetCachedUserName(uid);
-  if (user_name)
-    return user_name;
-  if (IsHost()) {
-    std::string name;
-    if (HostInfo::LookupUserName(uid, name))
-      return SetCachedUserName(uid, name.c_str(), name.size());
-  }
-#endif
-  return nullptr;
-}
-
-const char *Platform::GetGroupName(uint32_t gid) {
-#if !defined(LLDB_DISABLE_POSIX)
-  const char *group_name = GetCachedGroupName(gid);
-  if (group_name)
-    return group_name;
-  if (IsHost()) {
-    std::string name;
-    if (HostInfo::LookupGroupName(gid, name))
-      return SetCachedGroupName(gid, name.c_str(), name.size());
-  }
-#endif
-  return nullptr;
-}
-
 bool Platform::SetOSVersion(llvm::VersionTuple version) {
   if (IsHost()) {
     // We don't need anyone setting the OS version for the host platform, we
     // should be able to figure it out by calling HostInfo::GetOSVersion(...).
     return false;
   } else {
     // We have a remote platform, allow setting the target OS version if we
     // aren't connected, since if we are connected, we should be able to

source/Target/Process.cpp

 }
 
 bool ProcessProperties::GetStopOnExec() const {
   const uint32_t idx = ePropertyStopOnExec;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_properties[idx].default_uint_value != 0);
 }
 
-void ProcessInstanceInfo::Dump(Stream &s, Platform *platform) const {
-  const char *cstr;
+void ProcessInstanceInfo::Dump(Stream &s, UserIDResolver &resolver) const {
   if (m_pid != LLDB_INVALID_PROCESS_ID)
     s.Printf("    pid = %" PRIu64 "\n", m_pid);
 
   if (m_parent_pid != LLDB_INVALID_PROCESS_ID)
     s.Printf(" parent = %" PRIu64 "\n", m_parent_pid);
 
   if (m_executable) {
     s.Printf("   name = %s\n", m_executable.GetFilename().GetCString());
void ProcessInstanceInfo::Dump(Stream &s, UserIDResolver &resolver) const {
   s.Format("{0}", m_environment);
 
   if (m_arch.IsValid()) {
     s.Printf("   arch = ");
     m_arch.DumpTriple(s);
     s.EOL();
   }
 
-  if (m_uid != UINT32_MAX) {
-    cstr = platform->GetUserName(m_uid);
-    s.Printf("    uid = %-5u (%s)\n", m_uid, cstr ? cstr : "");
+  if (UserIDIsValid()) {
+    s.Format("    uid = {0,-5} ({1})\n", GetUserID(),
+             resolver.GetUserName(GetUserID()).getValueOr(""));
   }
-  if (m_gid != UINT32_MAX) {
-    cstr = platform->GetGroupName(m_gid);
-    s.Printf("    gid = %-5u (%s)\n", m_gid, cstr ? cstr : "");
+  if (GroupIDIsValid()) {
+    s.Format("    gid = {0,-5} ({1})\n", GetGroupID(),
+             resolver.GetGroupName(GetGroupID()).getValueOr(""));
   }
-  if (m_euid != UINT32_MAX) {
-    cstr = platform->GetUserName(m_euid);
-    s.Printf("   euid = %-5u (%s)\n", m_euid, cstr ? cstr : "");
+  if (EffectiveUserIDIsValid()) {
+    s.Format("   euid = {0,-5} ({1})\n", GetEffectiveUserID(),
+             resolver.GetUserName(GetEffectiveUserID()).getValueOr(""));
   }
-  if (m_egid != UINT32_MAX) {
-    cstr = platform->GetGroupName(m_egid);
-    s.Printf("   egid = %-5u (%s)\n", m_egid, cstr ? cstr : "");
+  if (EffectiveGroupIDIsValid()) {
+    s.Format("   egid = {0,-5} ({1})\n", GetEffectiveGroupID(),
+             resolver.GetGroupName(GetEffectiveGroupID()).getValueOr(""));
   }
 }
 
-void ProcessInstanceInfo::DumpTableHeader(Stream &s, Platform *platform,
-                                          bool show_args, bool verbose) {
+void ProcessInstanceInfo::DumpTableHeader(Stream &s, bool show_args,
+                                          bool verbose) {
   const char *label;
   if (show_args || verbose)
     label = "ARGUMENTS";
   else
     label = "NAME";
 
   if (verbose) {
     s.Printf("PID    PARENT USER       GROUP      EFF USER   EFF GROUP  TRIPLE "
              "                  %s\n",
              label);
     s.PutCString("====== ====== ========== ========== ========== ========== "
                  "======================== ============================\n");
   } else {
     s.Printf("PID    PARENT USER       TRIPLE                   %s\n", label);
     s.PutCString("====== ====== ========== ======================== "
                  "============================\n");
   }
 }
 
-void ProcessInstanceInfo::DumpAsTableRow(Stream &s, Platform *platform,
+void ProcessInstanceInfo::DumpAsTableRow(Stream &s, UserIDResolver &resolver,
                                          bool show_args, bool verbose) const {
   if (m_pid != LLDB_INVALID_PROCESS_ID) {
-    const char *cstr;
     s.Printf("%-6" PRIu64 " %-6" PRIu64 " ", m_pid, m_parent_pid);
 
     StreamString arch_strm;
     if (m_arch.IsValid())
       m_arch.DumpTriple(arch_strm);
 
-    if (verbose) {
-      cstr = platform->GetUserName(m_uid);
-      if (cstr &&
-          cstr[0]) // Watch for empty string that indicates lookup failed
-        s.Printf("%-10s ", cstr);
-      else
-        s.Printf("%-10u ", m_uid);
-
-      cstr = platform->GetGroupName(m_gid);
-      if (cstr &&
-          cstr[0]) // Watch for empty string that indicates lookup failed
-        s.Printf("%-10s ", cstr);
-      else
-        s.Printf("%-10u ", m_gid);
-
-      cstr = platform->GetUserName(m_euid);
-      if (cstr &&
-          cstr[0]) // Watch for empty string that indicates lookup failed
-        s.Printf("%-10s ", cstr);
+    auto print = [&](UserIDResolver::id_t id,
+                     llvm::Optional<llvm::StringRef> (UserIDResolver::*get)(
+                         UserIDResolver::id_t id)) {
+      if (auto name = (resolver.*get)(id))
+        s.Format("{0,-10} ", *name);
       else
-        s.Printf("%-10u ", m_euid);
-
-      cstr = platform->GetGroupName(m_egid);
-      if (cstr &&
-          cstr[0]) // Watch for empty string that indicates lookup failed
-        s.Printf("%-10s ", cstr);
-      else
-        s.Printf("%-10u ", m_egid);
+        s.Format("{0,-10} ", id);
+    };
+    if (verbose) {
+      print(m_uid, &UserIDResolver::GetUserName);
+      print(m_gid, &UserIDResolver::GetGroupName);
+      print(m_euid, &UserIDResolver::GetUserName);
+      print(m_egid, &UserIDResolver::GetGroupName);
 
       s.Printf("%-24s ", arch_strm.GetData());
     } else {
-      s.Printf("%-10s %-24s ", platform->GetUserName(m_euid),
-               arch_strm.GetData());
+      print(m_euid, &UserIDResolver::GetUserName);
+      s.Printf(" %-24s ", arch_strm.GetData());
     }
 
     if (verbose || show_args) {
       const uint32_t argc = m_arguments.GetArgumentCount();
       if (argc > 0) {
         for (uint32_t i = 0; i < argc; i++) {
           if (i > 0)
             s.PutChar(' ');
if (attach_info.GetExecutableFile().GetPath(process_name,
           if (num_matches == 1) {
             attach_pid = process_infos.GetProcessIDAtIndex(0);
             // Fall through and attach using the above process ID
           } else {
             match_info.GetProcessInfo().GetExecutableFile().GetPath(
                 process_name, sizeof(process_name));
             if (num_matches > 1) {
               StreamString s;
-              ProcessInstanceInfo::DumpTableHeader(s, platform_sp.get(), true,
-                                                   false);
+              ProcessInstanceInfo::DumpTableHeader(s, true, false);
               for (size_t i = 0; i < num_matches; i++) {
                 process_infos.GetProcessInfoAtIndex(i).DumpAsTableRow(
-                    s, platform_sp.get(), true, false);
+                    s, platform_sp->GetUserIDResolver(), true, false);
               }
               error.SetErrorStringWithFormat(
                   "more than one process named %s:\n%s", process_name,
                   s.GetData());
             } else
               error.SetErrorStringWithFormat(
                   "could not find a process named %s", process_name);
           }

source/Target/RemoteAwarePlatform.cpp

 //===-- RemoteAwarePlatform.cpp ---------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/RemoteAwarePlatform.h"
 #include "lldb/Host/FileCache.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Host/HostInfo.h"
 
 using namespace lldb_private;
 
 bool RemoteAwarePlatform::GetModuleSpec(const FileSpec &module_file_spec,
                                         const ArchSpec &arch,
                                         ModuleSpec &module_spec) {
   if (m_remote_platform_sp)
     return m_remote_platform_sp->GetModuleSpec(module_file_spec, arch,

 const char *RemoteAwarePlatform::GetHostname() {
   if (IsHost())
     return Platform::GetHostname();
   if (m_remote_platform_sp)
     return m_remote_platform_sp->GetHostname();
   return nullptr;
 }
 
-const char *RemoteAwarePlatform::GetUserName(uint32_t uid) {
-  // Check the cache in Platform in case we have already looked this uid up
-  const char *user_name = Platform::GetUserName(uid);
-  if (user_name)
-    return user_name;
-
-  if (IsRemote() && m_remote_platform_sp)
-    return m_remote_platform_sp->GetUserName(uid);
-  return nullptr;
-}
-
-const char *RemoteAwarePlatform::GetGroupName(uint32_t gid) {
-  const char *group_name = Platform::GetGroupName(gid);
-  if (group_name)
-    return group_name;
-
-  if (IsRemote() && m_remote_platform_sp)
-    return m_remote_platform_sp->GetGroupName(gid);
-  return nullptr;
+UserIDResolver &RemoteAwarePlatform::GetUserIDResolver() {
+  if (IsHost())
+    return HostInfo::GetUserIDResolver();
+  if (m_remote_platform_sp)
+    return m_remote_platform_sp->GetUserIDResolver();
+  return UserIDResolver::GetNoopResolver();
 }
 
 Environment RemoteAwarePlatform::GetEnvironment() {
   if (IsRemote()) {
     if (m_remote_platform_sp)
       return m_remote_platform_sp->GetEnvironment();
     return Environment();
   }

source/Utility/CMakeLists.txt

add_lldb_library(lldbUtility
   StringExtractor.cpp
   StringExtractorGDBRemote.cpp
   StringLexer.cpp
   StringList.cpp
   StructuredData.cpp
   TildeExpressionResolver.cpp
   Timer.cpp
   UserID.cpp
+  UserIDResolver.cpp
   UriParser.cpp
   UUID.cpp
   VASprintf.cpp
   VMRange.cpp
 
   LINK_LIBS
     ${LLDB_SYSTEM_LIBS}
     # lldbUtility does not depend on other LLDB libraries
 
   LINK_COMPONENTS
     BinaryFormat
     Support
   )

source/Utility/UserIDResolver.cpp

+//===-- UserIDResolver.cpp --------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Utility/UserIDResolver.h"
+#include "llvm/Support/ManagedStatic.h"
+
+using namespace lldb_private;
+
+UserIDResolver::~UserIDResolver() = default;
+
+llvm::Optional<llvm::StringRef> UserIDResolver::Get(
+    id_t id, Map &cache,
+    llvm::Optional<std::string> (UserIDResolver::*do_get)(id_t)) {
+
+  std::lock_guard<std::mutex> guard(m_mutex);
+  auto iter_bool = cache.try_emplace(id, llvm::None);
+  if (iter_bool.second)
+    iter_bool.first->second = (this->*do_get)(id);
+  if (iter_bool.first->second)
+    return llvm::StringRef(*iter_bool.first->second);
+  return llvm::None;
+}
+
+namespace {
+class NoopResolver : public UserIDResolver {
+protected:
+  llvm::Optional<std::string> DoGetUserName(id_t uid) override {
+    return llvm::None;
+  }
+
+  llvm::Optional<std::string> DoGetGroupName(id_t gid) override {
+    return llvm::None;
+  }
+};
+} // namespace
+
+static llvm::ManagedStatic<NoopResolver> g_noop_resolver;
+
+UserIDResolver &UserIDResolver::GetNoopResolver() { return *g_noop_resolver; }

unittests/Target/CMakeLists.txt

 add_lldb_unittest(TargetTests
   MemoryRegionInfoTest.cpp
   ModuleCacheTest.cpp
   PathMappingListTest.cpp
+  ProcessInstanceInfoTest.cpp
 
   LINK_LIBS
       lldbCore
       lldbHost
       lldbSymbol
       lldbUtility
       lldbPluginObjectFileELF
       lldbUtilityHelpers
     LINK_COMPONENTS
       Support
   )
 
 add_unittest_inputs(TargetTests TestModule.so)

unittests/Target/ProcessInstanceInfoTest.cpp

+//===-- ProcessInstanceInfoTest.cpp -----------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Target/Process.h"
+#include "gtest/gtest.h"
+
+using namespace lldb_private;
+
+namespace {
+/// A very simple resolver which fails for even ids and returns a simple string
+/// for odd ones.
+class DummyUserIDResolver : public UserIDResolver {
+protected:
+  llvm::Optional<std::string> DoGetUserName(id_t uid) {
+    if (uid % 2)
+      return ("user" + llvm::Twine(uid)).str();
+    return llvm::None;
+  }
+
+  llvm::Optional<std::string> DoGetGroupName(id_t gid) {
+    if (gid % 2)
+      return ("group" + llvm::Twine(gid)).str();
+    return llvm::None;
+  }
+};
+} // namespace
+
+TEST(ProcessInstanceInfo, Dump) {
+  ProcessInstanceInfo info("a.out", ArchSpec("x86_64-pc-linux"), 47);
+  info.SetUserID(1);
+  info.SetEffectiveUserID(2);
+  info.SetGroupID(3);
+  info.SetEffectiveGroupID(4);
+
+  DummyUserIDResolver resolver;
+  StreamString s;
+  info.Dump(s, resolver);
+  EXPECT_STREQ(R"(    pid = 47
+   name = a.out
+   file = a.out
+   arch = x86_64-pc-linux
+    uid = 1     (user1)
+    gid = 3     (group3)
+   euid = 2     ()
+   egid = 4     ()
+)",
+               s.GetData());
+}
+
+TEST(ProcessInstanceInfo, DumpTable) {
+  ProcessInstanceInfo info("a.out", ArchSpec("x86_64-pc-linux"), 47);
+  info.SetUserID(1);
+  info.SetEffectiveUserID(2);
+  info.SetGroupID(3);
+  info.SetEffectiveGroupID(4);
+
+  DummyUserIDResolver resolver;
+  StreamString s;
+
+  const bool show_args = false;
+  const bool verbose = true;
+  ProcessInstanceInfo::DumpTableHeader(s, show_args, verbose);
+  info.DumpAsTableRow(s, resolver, show_args, verbose);
+  EXPECT_STREQ(
+      R"(PID    PARENT USER       GROUP      EFF USER   EFF GROUP  TRIPLE                   ARGUMENTS
+====== ====== ========== ========== ========== ========== ======================== ============================
+47     0      user1      group3     2          4          x86_64-pc-linux          
+)",
+      s.GetData());
+}

unittests/Utility/CMakeLists.txt

add_lldb_unittest(UtilityTests
   StringExtractorTest.cpp
   StringLexerTest.cpp
   StringListTest.cpp
   StructuredDataTest.cpp
   TildeExpressionResolverTest.cpp
   TimeoutTest.cpp
   TimerTest.cpp
   UriParserTest.cpp
+  UserIDResolverTest.cpp
   UUIDTest.cpp
   VASprintfTest.cpp
   VMRangeTest.cpp
 
   LINK_LIBS
       lldbUtility
       lldbUtilityHelpers
       LLVMTestingSupport
   LINK_COMPONENTS
     Support
   )
 
 add_unittest_inputs(UtilityTests
   StructuredData-basic.json
   )

unittests/Utility/UserIDResolverTest.cpp

+//===-- UserIDResolverTest.cpp ----------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Utility/UserIDResolver.h"
+#include "gmock/gmock.h"
+
+using namespace lldb_private;
+using namespace testing;
+
+namespace {
+class TestUserIDResolver : public UserIDResolver {
+public:
+  MOCK_METHOD1(DoGetUserName, llvm::Optional<std::string>(id_t uid));
+  MOCK_METHOD1(DoGetGroupName, llvm::Optional<std::string>(id_t gid));
+};
+} // namespace
+
+TEST(UserIDResolver, GetUserName) {
+  StrictMock<TestUserIDResolver> r;
+  llvm::StringRef user47("foo");
+  EXPECT_CALL(r, DoGetUserName(47)).Times(1).WillOnce(Return(user47.str()));
+  EXPECT_CALL(r, DoGetUserName(42)).Times(1).WillOnce(Return(llvm::None));
+
+  // Call functions twice to make sure the caching works.
+  EXPECT_EQ(user47, r.GetUserName(47));
+  EXPECT_EQ(user47, r.GetUserName(47));
+  EXPECT_EQ(llvm::None, r.GetUserName(42));
+  EXPECT_EQ(llvm::None, r.GetUserName(42));
+}
+
+TEST(UserIDResolver, GetGroupName) {
+  StrictMock<TestUserIDResolver> r;
+  llvm::StringRef group47("foo");
+  EXPECT_CALL(r, DoGetGroupName(47)).Times(1).WillOnce(Return(group47.str()));
+  EXPECT_CALL(r, DoGetGroupName(42)).Times(1).WillOnce(Return(llvm::None));
+
+  // Call functions twice to make sure the caching works.
+  EXPECT_EQ(group47, r.GetGroupName(47));
+  EXPECT_EQ(group47, r.GetGroupName(47));
+  EXPECT_EQ(llvm::None, r.GetGroupName(42));
+  EXPECT_EQ(llvm::None, r.GetGroupName(42));
+}