[13/N] [libcxx] Implement the space function for windows

[mstorsjo]

Rebased on top of updated patches.

[amccarth]

LGTM.

[mstorsjo]

Rebased, triggering CI.

This one, contrary to many others, isn't done (yet) with a posix-like function in posix_compat.h - I guess one could try to create a fallback statvfs struct and all that even on windows if that's really needed though, but the ifdeffed code here is pretty selfcontained.

[ldionne]

I guess one could try to create a fallback statvfs struct and all that even on windows if that's really needed though, but the ifdeffed code here is pretty selfcontained.

That would be my preferred approach. Can you look into it and see if it can be done? If you remove this bit of windows-specific code from operations.cpp, I think this would LGTM.

[mstorsjo]

Moved the implementation into a statvfs interface in posix_compat.h.

[mstorsjo]

Retriggering CI.

[ldionne]

LGTM once CI passes!

[mstorsjo]

In D91168#2536746, @ldionne wrote:

LGTM once CI passes!

CI passed except for the one flaky config, thus pushing.

libcxx/src/filesystem/operations.cpp

void __resize_file(const path& p, uintmax_t size, error_code* ec) {
   ErrorHandler<void> err("resize_file", ec, &p);
   if (detail::truncate(p.c_str(), static_cast< ::off_t>(size)) == -1)
     return err.report(capture_errno());
 }
 
 space_info __space(const path& p, error_code* ec) {
   ErrorHandler<void> err("space", ec, &p);
   space_info si;
-  struct statvfs m_svfs = {};
-  if (::statvfs(p.c_str(), &m_svfs) == -1) {
+  detail::StatVFS m_svfs = {};
+  if (detail::statvfs(p.c_str(), &m_svfs) == -1) {
     err.report(capture_errno());
     si.capacity = si.free = si.available = static_cast<uintmax_t>(-1);
     return si;
   }
   // Multiply with overflow checking.
   auto do_mult = [&](uintmax_t& out, uintmax_t other) {
     out = other * m_svfs.f_frsize;
     if (other == 0 || out / other != m_svfs.f_frsize)

libcxx/src/filesystem/posix_compat.h

int rename(const wchar_t *from, const wchar_t *to) {
   return 0;
 }
 
 template <class... Args> int open(const wchar_t *filename, Args... args) {
   return _wopen(filename, args...);
 }
 int close(int fd) { return _close(fd); }
 int chdir(const wchar_t *path) { return _wchdir(path); }
+
+struct StatVFS {
+  uint64_t f_frsize;
+  uint64_t f_blocks;
+  uint64_t f_bfree;
+  uint64_t f_bavail;
+};
+
+int statvfs(const wchar_t *p, StatVFS *buf) {
+  path dir = p;
+  while (true) {
+    error_code local_ec;
+    const file_status st = status(dir, local_ec);
+    if (!exists(st) || is_directory(st))
+      break;
+    path parent = dir.parent_path();
+    if (parent == dir) {
+      errno = ENOENT;
+      return -1;
+    }
+    dir = parent;
+  }
+  ULARGE_INTEGER free_bytes_available_to_caller, total_number_of_bytes,
+      total_number_of_free_bytes;
+  if (!GetDiskFreeSpaceExW(dir.c_str(), &free_bytes_available_to_caller,
+                           &total_number_of_bytes, &total_number_of_free_bytes))
+    return set_errno();
+  buf->f_frsize = 1;
+  buf->f_blocks = total_number_of_bytes.QuadPart;
+  buf->f_bfree = total_number_of_free_bytes.QuadPart;
+  buf->f_bavail = free_bytes_available_to_caller.QuadPart;
+  return 0;
+}
+
 #else
 int symlink_file(const char *oldname, const char *newname) {
   return ::symlink(oldname, newname);
 }
 int symlink_dir(const char *oldname, const char *newname) {
   return ::symlink(oldname, newname);
 }
 using ::chdir;
 using ::close;
 using ::fstat;
 using ::ftruncate;
 using ::link;
 using ::lstat;
 using ::mkdir;
 using ::open;
 using ::remove;
 using ::rename;
 using ::stat;
+using ::statvfs;
 using ::truncate;
 
 #define O_BINARY 0
 
+using StatVFS = struct statvfs;
+
 #endif
 
 } // namespace
 } // end namespace detail
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 #endif // POSIX_COMPAT_H