8338851: Hoist os::Posix::realpath() to os::realpath() and implement …

…on Windows

Reviewed-by: dholmes, stuefe, jwaters

src/hotspot/os/aix/os_aix.cpp

@@ -1293,7 +1293,7 @@ void os::jvm_path(char *buf, jint buflen) {
  Dl_info dlinfo;
  int ret = dladdr(CAST_FROM_FN_PTR(void *, os::jvm_path), &dlinfo);
  assert(ret != 0, "cannot locate libjvm");
- char* rp = os::Posix::realpath((char *)dlinfo.dli_fname, buf, buflen);
+ char* rp = os::realpath((char *)dlinfo.dli_fname, buf, buflen);
  assert(rp != nullptr, "error in realpath(): maybe the 'path' argument is too long?");
 
  if (Arguments::sun_java_launcher_is_altjvm()) {
@@ -1324,7 +1324,7 @@ void os::jvm_path(char *buf, jint buflen) {
  }
  assert(strstr(p, "/libjvm") == p, "invalid library name");
 
- rp = os::Posix::realpath(java_home_var, buf, buflen);
+ rp = os::realpath(java_home_var, buf, buflen);
  if (rp == nullptr) {
  return;
  }
@@ -1345,7 +1345,7 @@ void os::jvm_path(char *buf, jint buflen) {
  snprintf(buf + len, buflen-len, "/hotspot/libjvm.so");
  } else {
  // Go back to path of .so
- rp = os::Posix::realpath((char *)dlinfo.dli_fname, buf, buflen);
+ rp = os::realpath((char *)dlinfo.dli_fname, buf, buflen);
  if (rp == nullptr) {
  return;
  }

src/hotspot/os/bsd/os_bsd.cpp

@@ -1509,7 +1509,7 @@ void os::jvm_path(char *buf, jint buflen) {
  assert(ret, "cannot locate libjvm");
  char *rp = nullptr;
  if (ret && dli_fname[0] != '\0') {
- rp = os::Posix::realpath(dli_fname, buf, buflen);
+ rp = os::realpath(dli_fname, buf, buflen);
  }
  if (rp == nullptr) {
  return;
@@ -1541,7 +1541,7 @@ void os::jvm_path(char *buf, jint buflen) {
  p = strrchr(buf, '/');
  assert(strstr(p, "/libjvm") == p, "invalid library name");
 
- rp = os::Posix::realpath(java_home_var, buf, buflen);
+ rp = os::realpath(java_home_var, buf, buflen);
  if (rp == nullptr) {
  return;
  }
@@ -1575,7 +1575,7 @@ void os::jvm_path(char *buf, jint buflen) {
  snprintf(buf + len, buflen-len, "/libjvm%s", JNI_LIB_SUFFIX);
  } else {
  // Fall back to path of current library
- rp = os::Posix::realpath(dli_fname, buf, buflen);
+ rp = os::realpath(dli_fname, buf, buflen);
  if (rp == nullptr) {
  return;
  }

src/hotspot/os/linux/os_linux.cpp

@@ -2763,7 +2763,7 @@ void os::jvm_path(char *buf, jint buflen) {
  assert(ret, "cannot locate libjvm");
  char *rp = nullptr;
  if (ret && dli_fname[0] != '\0') {
- rp = os::Posix::realpath(dli_fname, buf, buflen);
+ rp = os::realpath(dli_fname, buf, buflen);
  }
  if (rp == nullptr) {
  return;
@@ -2797,7 +2797,7 @@ void os::jvm_path(char *buf, jint buflen) {
  }
  assert(strstr(p, "/libjvm") == p, "invalid library name");
 
- rp = os::Posix::realpath(java_home_var, buf, buflen);
+ rp = os::realpath(java_home_var, buf, buflen);
  if (rp == nullptr) {
  return;
  }
@@ -2818,7 +2818,7 @@ void os::jvm_path(char *buf, jint buflen) {
  snprintf(buf + len, buflen-len, "/hotspot/libjvm.so");
  } else {
  // Go back to path of .so
- rp = os::Posix::realpath(dli_fname, buf, buflen);
+ rp = os::realpath(dli_fname, buf, buflen);
  if (rp == nullptr) {
  return;
  }

src/hotspot/os/linux/os_perf_linux.cpp

@@ -789,7 +789,7 @@ char* SystemProcessInterface::SystemProcesses::ProcessIterator::get_exe_path() {
 
  jio_snprintf(buffer, PATH_MAX, "/proc/%s/exe", _entry->d_name);
  buffer[PATH_MAX - 1] = '\0';
- return os::Posix::realpath(buffer, _exePath, PATH_MAX);
+ return os::realpath(buffer, _exePath, PATH_MAX);
 }
 
 char* SystemProcessInterface::SystemProcesses::ProcessIterator::allocate_string(const char* str) const {

src/hotspot/os/posix/os_posix.cpp

@@ -1029,10 +1029,10 @@ char* os::Posix::describe_pthread_attr(char* buf, size_t buflen, const pthread_a
  return buf;
 }
 
-char* os::Posix::realpath(const char* filename, char* outbuf, size_t outbuflen) {
+char* os::realpath(const char* filename, char* outbuf, size_t outbuflen) {
 
  if (filename == nullptr || outbuf == nullptr || outbuflen < 1) {
- assert(false, "os::Posix::realpath: invalid arguments.");
+ assert(false, "os::realpath: invalid arguments.");
  errno = EINVAL;
  return nullptr;
  }
@@ -1067,7 +1067,6 @@ char* os::Posix::realpath(const char* filename, char* outbuf, size_t outbuflen)
  }
  }
  return result;
-
 }
 
 int os::stat(const char *path, struct stat *sbuf) {

src/hotspot/os/posix/os_posix.hpp

@@ -73,13 +73,6 @@ class os::Posix {
  // to buf with len buflen; buf is returned.
  static char* describe_pthread_attr(char* buf, size_t buflen, const pthread_attr_t* attr);
 
- // A safe implementation of realpath which will not cause a buffer overflow if the resolved path
- // is longer than PATH_MAX.
- // On success, returns 'outbuf', which now contains the path.
- // On error, it will return null and set errno. The content of 'outbuf' is undefined.
- // On truncation error ('outbuf' too small), it will return null and set errno to ENAMETOOLONG.
- static char* realpath(const char* filename, char* outbuf, size_t outbuflen);
-
  // Returns true if given uid is root.
  static bool is_root(uid_t uid);
 

src/hotspot/os/windows/os_windows.cpp

@@ -5397,6 +5397,28 @@ void os::funlockfile(FILE* fp) {
  _unlock_file(fp);
 }
 
+char* os::realpath(const char* filename, char* outbuf, size_t outbuflen) {
+
+ if (filename == nullptr || outbuf == nullptr || outbuflen < 1) {
+ assert(false, "os::realpath: invalid arguments.");
+ errno = EINVAL;
+ return nullptr;
+ }
+
+ char* result = nullptr;
+ ALLOW_C_FUNCTION(::_fullpath, char* p = ::_fullpath(nullptr, filename, 0);)
+ if (p != nullptr) {
+ if (strlen(p) < outbuflen) {
+ strcpy(outbuf, p);
+ result = outbuf;
+ } else {
+ errno = ENAMETOOLONG;
+ }
+ ALLOW_C_FUNCTION(::free, ::free(p);) // *not* os::free
+ }
+ return result;
+}
+
 // Map a block of memory.
 char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset,
  char *addr, size_t bytes, bool read_only,

src/hotspot/share/runtime/os.hpp

@@ -668,6 +668,13 @@ class os: AllStatic {
  static void flockfile(FILE* fp);
  static void funlockfile(FILE* fp);
 
+ // A safe implementation of realpath which will not cause a buffer overflow if the resolved path
+ // is longer than PATH_MAX.
+ // On success, returns 'outbuf', which now contains the path.
+ // On error, it will return null and set errno. The content of 'outbuf' is undefined.
+ // On truncation error ('outbuf' too small), it will return null and set errno to ENAMETOOLONG.
+ static char* realpath(const char* filename, char* outbuf, size_t outbuflen);
+
  static int compare_file_modified_times(const char* file1, const char* file2);
 
  static bool same_files(const char* file1, const char* file2);

src/hotspot/share/services/diagnosticCommand.cpp

@@ -1202,12 +1202,10 @@ void SystemDumpMapDCmd::execute(DCmdSource source, TRAPS) {
  output()->print_cr("(NMT is disabled, will not annotate mappings).");
  }
  MemMapPrinter::print_all_mappings(&fs);
-#ifndef _WIN64
  // For the readers convenience, resolve path name.
  char tmp[JVM_MAXPATHLEN];
- const char* absname = os::Posix::realpath(name, tmp, sizeof(tmp));
+ const char* absname = os::realpath(name, tmp, sizeof(tmp));
  name = absname != nullptr ? absname : name;
-#endif
  output()->print_cr("Memory map dumped to \"%s\".", name);
  } else {
  output()->print_cr("Failed to open \"%s\" for writing (%s).", name, os::strerror(errno));

src/hotspot/share/utilities/globalDefinitions.hpp

@@ -210,7 +210,7 @@ FORBID_C_FUNCTION(char* strdup(const char *s), "use os::strdup");
 FORBID_C_FUNCTION(char* strndup(const char *s, size_t n), "don't use");
 FORBID_C_FUNCTION(int posix_memalign(void **memptr, size_t alignment, size_t size), "don't use");
 FORBID_C_FUNCTION(void* aligned_alloc(size_t alignment, size_t size), "don't use");
-FORBID_C_FUNCTION(char* realpath(const char* path, char* resolved_path), "use os::Posix::realpath");
+FORBID_C_FUNCTION(char* realpath(const char* path, char* resolved_path), "use os::realpath");
 FORBID_C_FUNCTION(char* get_current_dir_name(void), "use os::get_current_directory()");
 FORBID_C_FUNCTION(char* getwd(char *buf), "use os::get_current_directory()");
 FORBID_C_FUNCTION(wchar_t* wcsdup(const wchar_t *s), "don't use");

test/hotspot/gtest/runtime/test_os.cpp

@@ -405,6 +405,86 @@ TEST_VM(os, jio_snprintf) {
  test_snprintf(jio_snprintf, false);
 }
 
+#ifndef MAX_PATH
+#define MAX_PATH (2 * K)
+#endif
+
+TEST_VM(os, realpath) {
+ // POSIX requires that the file exists; Windows tests for a valid drive letter
+ // but may or may not test if the file exists. */
+ static const char* nosuchpath = "/1234567890123456789";
+ static const char* tmppath = "/tmp";
+
+ char buffer[MAX_PATH];
+
+ // Test a non-existant path, but provide a short buffer.
+ errno = 0;
+ const char* returnedBuffer = os::realpath(nosuchpath, buffer, sizeof(nosuchpath) - 2);
+ // Reports ENOENT on Linux, ENAMETOOLONG on Windows.
+ EXPECT_TRUE(returnedBuffer == nullptr);
+#ifdef _WINDOWS
+ EXPECT_TRUE(errno == ENAMETOOLONG);
+#else
+ EXPECT_TRUE(errno == ENOENT);
+#endif
+
+ // Test a non-existant path, but provide an adequate buffer.
+ errno = 0;
+ buffer[0] = 0;
+ returnedBuffer = os::realpath(nosuchpath, buffer, sizeof(nosuchpath) + 3);
+ // Reports ENOENT on Linux, may return 0 (and report an error) or buffer on some versions of Windows.
+#ifdef _WINDOWS
+ if (returnedBuffer != nullptr) {
+ EXPECT_TRUE(returnedBuffer == buffer);
+ } else {
+ EXPECT_TRUE(errno != 0);
+ }
+#else
+ EXPECT_TRUE(returnedBuffer == nullptr);
+ EXPECT_TRUE(errno == ENOENT);
+#endif
+
+ // Test an existing path using a large buffer.
+ errno = 0;
+ returnedBuffer = os::realpath(tmppath, buffer, MAX_PATH);
+ EXPECT_TRUE(returnedBuffer == buffer);
+
+ // Test an existing path using a buffer that is too small on a normal macOS install.
+ errno = 0;
+ returnedBuffer = os::realpath(tmppath, buffer, strlen(tmppath) + 3);
+ // On MacOS, /tmp is a symlink to /private/tmp, so doesn't fit in a small buffer.
+#ifndef __APPLE__
+ EXPECT_TRUE(returnedBuffer == buffer);
+#else
+ EXPECT_TRUE(returnedBuffer == nullptr);
+ EXPECT_TRUE(errno == ENAMETOOLONG);
+#endif
+
+ // Test an existing path using a buffer that is too small.
+ errno = 0;
+ returnedBuffer = os::realpath(tmppath, buffer, strlen(tmppath) - 1);
+ EXPECT_TRUE(returnedBuffer == nullptr);
+ EXPECT_TRUE(errno == ENAMETOOLONG);
+
+ // The following tests cause an assert inside os::realpath() in fastdebug mode:
+#ifndef ASSERT
+ errno = 0;
+ returnedBuffer = os::realpath(nullptr, buffer, sizeof(buffer));
+ EXPECT_TRUE(returnedBuffer == nullptr);
+ EXPECT_TRUE(errno == EINVAL);
+
+ errno = 0;
+ returnedBuffer = os::realpath(tmppath, nullptr, sizeof(buffer));
+ EXPECT_TRUE(returnedBuffer == nullptr);
+ EXPECT_TRUE(errno == EINVAL);
+
+ errno = 0;
+ returnedBuffer = os::realpath(tmppath, buffer, 0);
+ EXPECT_TRUE(returnedBuffer == nullptr);
+ EXPECT_TRUE(errno == EINVAL);
+#endif
+}
+
 #ifdef __APPLE__
 // Not all macOS versions can use os::reserve_memory (i.e. anon_mmap) API
 // to reserve executable memory, so before attempting to use it,