[Msan] Fix the unit tests' PathToLoadable() to work on FreeBSD

[kutuzov.viktor.84]

lib/msan/tests/msan_test.cc

2850 ↗

(On Diff #19822)

Hm, with the returning type eliminated we may want to rename it to GetPathToLoadable()?

[samsonov]

lib/msan/tests/msan_test.cc

109 ↗

(On Diff #19822)

kMaxPathLength?

2850 ↗

(On Diff #19822)

Yes, please.

2862 ↗

(On Diff #19822)

Please run clang-format on this diff

[kutuzov.viktor.84]

Updated.

[samsonov]

LGTM

compiler-rt/trunk/lib/msan/tests/msan_test.cc

 # include <mntent.h>
 # include <netinet/ether.h>
 #else
 # include <signal.h>
 # include <netinet/in.h>
 # include <pthread_np.h>
 # include <sys/uio.h>
 # include <sys/mount.h>
+# include <sys/sysctl.h>
 # include <net/ethernet.h>
 # define f_namelen f_namemax  // FreeBSD names this statfs field so.
 # define cpu_set_t cpuset_t
 extern "C" {
 // FreeBSD's <ssp/string.h> defines mempcpy() to be a macro expanding into
 // a __builtin___mempcpy_chk() call, but since Msan RTL defines it as an
 // ordinary function, we can declare it here to complete the tests.
 void *mempcpy(void *dest, const void *src, size_t n);

 #else
 # define FILE_TO_READ "/proc/self/stat"
 # define DIR_TO_READ "/proc/self"
 # define SUBFILE_TO_READ "stat"
 # define SYMLINK_TO_READ "/proc/self/exe"
 # define SUPERUSER_GROUP "root"
 #endif
 
-static const size_t kPageSize = 4096;
+const size_t kPageSize = 4096;
+const size_t kMaxPathLength = 4096;
 
 typedef unsigned char      U1;
 typedef unsigned short     U2;  // NOLINT
 typedef unsigned int       U4;
 typedef unsigned long long U8;  // NOLINT
 typedef   signed char      S1;
 typedef   signed short     S2;  // NOLINT
 typedef   signed int       S4;
TEST(MemorySanitizer, getrusage) {
   EXPECT_NOT_POISONED(usage.ru_minflt);
   EXPECT_NOT_POISONED(usage.ru_majflt);
   EXPECT_NOT_POISONED(usage.ru_inblock);
   EXPECT_NOT_POISONED(usage.ru_oublock);
   EXPECT_NOT_POISONED(usage.ru_nvcsw);
   EXPECT_NOT_POISONED(usage.ru_nivcsw);
 }
 
-#ifdef __GLIBC__
+#if defined(__FreeBSD__)
+static void GetProgramPath(char *buf, size_t sz) {
+  int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1 };
+  int res = sysctl(mib, 4, buf, &sz, NULL, 0);
+  ASSERT_EQ(0, res);
+}
+#elif defined(__GLIBC__)
+static void GetProgramPath(char *buf, size_t sz) {
   extern char *program_invocation_name;
-#else  // __GLIBC__
+  int res = snprintf(buf, sz, "%s", program_invocation_name);
+  ASSERT_GE(res, 0);
+  ASSERT_LT((size_t)res, sz);
+}
+#else
 # error "TODO: port this"
 #endif
 
 static void dladdr_testfn() {}
 
 TEST(MemorySanitizer, dladdr) {
   Dl_info info;
   __msan_poison(&info, sizeof(info));
static int dl_phdr_callback(struct dl_phdr_info *info, size_t size, void *data) {
   EXPECT_NOT_POISONED(info->dlpi_phnum);
   for (int i = 0; i < info->dlpi_phnum; ++i)
     EXPECT_NOT_POISONED(info->dlpi_phdr[i]);
   return 0;
 }
 
 // Compute the path to our loadable DSO.  We assume it's in the same
 // directory.  Only use string routines that we intercept so far to do this.
-static int PathToLoadable(char *buf, size_t sz) {
-  const char *basename = "libmsan_loadable.x86_64.so";
-  char *argv0 = program_invocation_name;
-  char *last_slash = strrchr(argv0, '/');
-  assert(last_slash);
-  int res =
-      snprintf(buf, sz, "%.*s/%s", int(last_slash - argv0), argv0, basename);
-  assert(res >= 0);
-  return (size_t)res < sz ? 0 : res;
+static void GetPathToLoadable(char *buf, size_t sz) {
+  char program_path[kMaxPathLength];
+  GetProgramPath(program_path, sizeof(program_path));
+
+  const char *last_slash = strrchr(program_path, '/');
+  ASSERT_NE(nullptr, last_slash);
+  size_t dir_len = (size_t)(last_slash - program_path);
+
+  static const char basename[] = "libmsan_loadable.x86_64.so";
+  int res = snprintf(buf, sz, "%.*s/%s",
+                     (int)dir_len, program_path, basename);
+  ASSERT_GE(res, 0);
+  ASSERT_LT((size_t)res, sz);
 }
 
 TEST(MemorySanitizer, dl_iterate_phdr) {
-  char path[4096];
-  int res = PathToLoadable(path, sizeof(path));
-  ASSERT_EQ(0, res);
+  char path[kMaxPathLength];
+  GetPathToLoadable(path, sizeof(path));
 
   // Having at least one dlopen'ed library in the process makes this more
   // entertaining.
   void *lib = dlopen(path, RTLD_LAZY);
   ASSERT_NE((void*)0, lib);
 
   int count = 0;
   int result = dl_iterate_phdr(dl_phdr_callback, &count);
   ASSERT_GT(count, 0);
-  
   dlclose(lib);
 }
 
-
 TEST(MemorySanitizer, dlopen) {
-  char path[4096];
-  int res = PathToLoadable(path, sizeof(path));
-  ASSERT_EQ(0, res);
+  char path[kMaxPathLength];
+  GetPathToLoadable(path, sizeof(path));
 
   // We need to clear shadow for globals when doing dlopen.  In order to test
   // this, we have to poison the shadow for the DSO before we load it.  In
   // general this is difficult, but the loader tends to reload things in the
   // same place, so we open, close, and then reopen.  The global should always
   // start out clean after dlopen.
   for (int i = 0; i < 2; i++) {
     void *lib = dlopen(path, RTLD_LAZY);