/Users/buildslave/jenkins/workspace/coverage/llvm-project/libcxx/src/filesystem/posix_compat.h
Line | Count | Source (jump to first uncovered line) |
1 | | //===----------------------------------------------------------------------===// |
2 | | // |
3 | | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | | // See https://llvm.org/LICENSE.txt for license information. |
5 | | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | | // |
7 | | //===----------------------------------------------------------------------===// |
8 | | |
9 | | // |
10 | | // POSIX-like portability helper functions. |
11 | | // |
12 | | // These generally behave like the proper posix functions, with these |
13 | | // exceptions: |
14 | | // On Windows, they take paths in wchar_t* form, instead of char* form. |
15 | | // The symlink() function is split into two frontends, symlink_file() |
16 | | // and symlink_dir(). |
17 | | // |
18 | | // These are provided within an anonymous namespace within the detail |
19 | | // namespace - callers need to include this header and call them as |
20 | | // detail::function(), regardless of platform. |
21 | | // |
22 | | |
23 | | #ifndef POSIX_COMPAT_H |
24 | | #define POSIX_COMPAT_H |
25 | | |
26 | | #include <__assert> |
27 | | #include <filesystem> |
28 | | |
29 | | #include "filesystem_common.h" |
30 | | |
31 | | #if defined(_LIBCPP_WIN32API) |
32 | | # define WIN32_LEAN_AND_MEAN |
33 | | # define NOMINMAX |
34 | | # include <windows.h> |
35 | | # include <io.h> |
36 | | # include <winioctl.h> |
37 | | #else |
38 | | # include <unistd.h> |
39 | | # include <sys/stat.h> |
40 | | # include <sys/statvfs.h> |
41 | | #endif |
42 | | #include <time.h> |
43 | | |
44 | | #if defined(_LIBCPP_WIN32API) |
45 | | // This struct isn't defined in the normal Windows SDK, but only in the |
46 | | // Windows Driver Kit. |
47 | | struct LIBCPP_REPARSE_DATA_BUFFER { |
48 | | unsigned long ReparseTag; |
49 | | unsigned short ReparseDataLength; |
50 | | unsigned short Reserved; |
51 | | union { |
52 | | struct { |
53 | | unsigned short SubstituteNameOffset; |
54 | | unsigned short SubstituteNameLength; |
55 | | unsigned short PrintNameOffset; |
56 | | unsigned short PrintNameLength; |
57 | | unsigned long Flags; |
58 | | wchar_t PathBuffer[1]; |
59 | | } SymbolicLinkReparseBuffer; |
60 | | struct { |
61 | | unsigned short SubstituteNameOffset; |
62 | | unsigned short SubstituteNameLength; |
63 | | unsigned short PrintNameOffset; |
64 | | unsigned short PrintNameLength; |
65 | | wchar_t PathBuffer[1]; |
66 | | } MountPointReparseBuffer; |
67 | | struct { |
68 | | unsigned char DataBuffer[1]; |
69 | | } GenericReparseBuffer; |
70 | | }; |
71 | | }; |
72 | | #endif |
73 | | |
74 | | _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM |
75 | | |
76 | | namespace detail { |
77 | | namespace { |
78 | | |
79 | | #if defined(_LIBCPP_WIN32API) |
80 | | |
81 | | // Various C runtime header sets provide more or less of these. As we |
82 | | // provide our own implementation, undef all potential defines from the |
83 | | // C runtime headers and provide a complete set of macros of our own. |
84 | | |
85 | | #undef _S_IFMT |
86 | | #undef _S_IFDIR |
87 | | #undef _S_IFCHR |
88 | | #undef _S_IFIFO |
89 | | #undef _S_IFREG |
90 | | #undef _S_IFBLK |
91 | | #undef _S_IFLNK |
92 | | #undef _S_IFSOCK |
93 | | |
94 | | #define _S_IFMT 0xF000 |
95 | | #define _S_IFDIR 0x4000 |
96 | | #define _S_IFCHR 0x2000 |
97 | | #define _S_IFIFO 0x1000 |
98 | | #define _S_IFREG 0x8000 |
99 | | #define _S_IFBLK 0x6000 |
100 | | #define _S_IFLNK 0xA000 |
101 | | #define _S_IFSOCK 0xC000 |
102 | | |
103 | | #undef S_ISDIR |
104 | | #undef S_ISFIFO |
105 | | #undef S_ISCHR |
106 | | #undef S_ISREG |
107 | | #undef S_ISLNK |
108 | | #undef S_ISBLK |
109 | | #undef S_ISSOCK |
110 | | |
111 | | #define S_ISDIR(m) (((m) & _S_IFMT) == _S_IFDIR) |
112 | | #define S_ISCHR(m) (((m) & _S_IFMT) == _S_IFCHR) |
113 | | #define S_ISFIFO(m) (((m) & _S_IFMT) == _S_IFIFO) |
114 | | #define S_ISREG(m) (((m) & _S_IFMT) == _S_IFREG) |
115 | | #define S_ISBLK(m) (((m) & _S_IFMT) == _S_IFBLK) |
116 | | #define S_ISLNK(m) (((m) & _S_IFMT) == _S_IFLNK) |
117 | | #define S_ISSOCK(m) (((m) & _S_IFMT) == _S_IFSOCK) |
118 | | |
119 | | #define O_NONBLOCK 0 |
120 | | |
121 | | |
122 | | // There were 369 years and 89 leap days from the Windows epoch |
123 | | // (1601) to the Unix epoch (1970). |
124 | | #define FILE_TIME_OFFSET_SECS (uint64_t(369 * 365 + 89) * (24 * 60 * 60)) |
125 | | |
126 | | TimeSpec filetime_to_timespec(LARGE_INTEGER li) { |
127 | | TimeSpec ret; |
128 | | ret.tv_sec = li.QuadPart / 10000000 - FILE_TIME_OFFSET_SECS; |
129 | | ret.tv_nsec = (li.QuadPart % 10000000) * 100; |
130 | | return ret; |
131 | | } |
132 | | |
133 | | TimeSpec filetime_to_timespec(FILETIME ft) { |
134 | | LARGE_INTEGER li; |
135 | | li.LowPart = ft.dwLowDateTime; |
136 | | li.HighPart = ft.dwHighDateTime; |
137 | | return filetime_to_timespec(li); |
138 | | } |
139 | | |
140 | | FILETIME timespec_to_filetime(TimeSpec ts) { |
141 | | LARGE_INTEGER li; |
142 | | li.QuadPart = |
143 | | ts.tv_nsec / 100 + (ts.tv_sec + FILE_TIME_OFFSET_SECS) * 10000000; |
144 | | FILETIME ft; |
145 | | ft.dwLowDateTime = li.LowPart; |
146 | | ft.dwHighDateTime = li.HighPart; |
147 | | return ft; |
148 | | } |
149 | | |
150 | | int set_errno(int e = GetLastError()) { |
151 | | errno = static_cast<int>(__win_err_to_errc(e)); |
152 | | return -1; |
153 | | } |
154 | | |
155 | | class WinHandle { |
156 | | public: |
157 | | WinHandle(const wchar_t *p, DWORD access, DWORD flags) { |
158 | | h = CreateFileW( |
159 | | p, access, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, |
160 | | nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | flags, nullptr); |
161 | | } |
162 | | ~WinHandle() { |
163 | | if (h != INVALID_HANDLE_VALUE) |
164 | | CloseHandle(h); |
165 | | } |
166 | | operator HANDLE() const { return h; } |
167 | | operator bool() const { return h != INVALID_HANDLE_VALUE; } |
168 | | |
169 | | private: |
170 | | HANDLE h; |
171 | | }; |
172 | | |
173 | | int stat_handle(HANDLE h, StatT *buf) { |
174 | | FILE_BASIC_INFO basic; |
175 | | if (!GetFileInformationByHandleEx(h, FileBasicInfo, &basic, sizeof(basic))) |
176 | | return set_errno(); |
177 | | memset(buf, 0, sizeof(*buf)); |
178 | | buf->st_mtim = filetime_to_timespec(basic.LastWriteTime); |
179 | | buf->st_atim = filetime_to_timespec(basic.LastAccessTime); |
180 | | buf->st_mode = 0555; // Read-only |
181 | | if (!(basic.FileAttributes & FILE_ATTRIBUTE_READONLY)) |
182 | | buf->st_mode |= 0222; // Write |
183 | | if (basic.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) { |
184 | | buf->st_mode |= _S_IFDIR; |
185 | | } else { |
186 | | buf->st_mode |= _S_IFREG; |
187 | | } |
188 | | if (basic.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) { |
189 | | FILE_ATTRIBUTE_TAG_INFO tag; |
190 | | if (!GetFileInformationByHandleEx(h, FileAttributeTagInfo, &tag, |
191 | | sizeof(tag))) |
192 | | return set_errno(); |
193 | | if (tag.ReparseTag == IO_REPARSE_TAG_SYMLINK) |
194 | | buf->st_mode = (buf->st_mode & ~_S_IFMT) | _S_IFLNK; |
195 | | } |
196 | | FILE_STANDARD_INFO standard; |
197 | | if (!GetFileInformationByHandleEx(h, FileStandardInfo, &standard, |
198 | | sizeof(standard))) |
199 | | return set_errno(); |
200 | | buf->st_nlink = standard.NumberOfLinks; |
201 | | buf->st_size = standard.EndOfFile.QuadPart; |
202 | | BY_HANDLE_FILE_INFORMATION info; |
203 | | if (!GetFileInformationByHandle(h, &info)) |
204 | | return set_errno(); |
205 | | buf->st_dev = info.dwVolumeSerialNumber; |
206 | | memcpy(&buf->st_ino.id[0], &info.nFileIndexHigh, 4); |
207 | | memcpy(&buf->st_ino.id[4], &info.nFileIndexLow, 4); |
208 | | return 0; |
209 | | } |
210 | | |
211 | | int stat_file(const wchar_t *path, StatT *buf, DWORD flags) { |
212 | | WinHandle h(path, FILE_READ_ATTRIBUTES, flags); |
213 | | if (!h) |
214 | | return set_errno(); |
215 | | int ret = stat_handle(h, buf); |
216 | | return ret; |
217 | | } |
218 | | |
219 | | int stat(const wchar_t *path, StatT *buf) { return stat_file(path, buf, 0); } |
220 | | |
221 | | int lstat(const wchar_t *path, StatT *buf) { |
222 | | return stat_file(path, buf, FILE_FLAG_OPEN_REPARSE_POINT); |
223 | | } |
224 | | |
225 | | int fstat(int fd, StatT *buf) { |
226 | | HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd)); |
227 | | return stat_handle(h, buf); |
228 | | } |
229 | | |
230 | | int mkdir(const wchar_t *path, int permissions) { |
231 | | (void)permissions; |
232 | | return _wmkdir(path); |
233 | | } |
234 | | |
235 | | int symlink_file_dir(const wchar_t *oldname, const wchar_t *newname, |
236 | | bool is_dir) { |
237 | | path dest(oldname); |
238 | | dest.make_preferred(); |
239 | | oldname = dest.c_str(); |
240 | | DWORD flags = is_dir ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0; |
241 | | if (CreateSymbolicLinkW(newname, oldname, |
242 | | flags | SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE)) |
243 | | return 0; |
244 | | int e = GetLastError(); |
245 | | if (e != ERROR_INVALID_PARAMETER) |
246 | | return set_errno(e); |
247 | | if (CreateSymbolicLinkW(newname, oldname, flags)) |
248 | | return 0; |
249 | | return set_errno(); |
250 | | } |
251 | | |
252 | | int symlink_file(const wchar_t *oldname, const wchar_t *newname) { |
253 | | return symlink_file_dir(oldname, newname, false); |
254 | | } |
255 | | |
256 | | int symlink_dir(const wchar_t *oldname, const wchar_t *newname) { |
257 | | return symlink_file_dir(oldname, newname, true); |
258 | | } |
259 | | |
260 | | int link(const wchar_t *oldname, const wchar_t *newname) { |
261 | | if (CreateHardLinkW(newname, oldname, nullptr)) |
262 | | return 0; |
263 | | return set_errno(); |
264 | | } |
265 | | |
266 | | int remove(const wchar_t *path) { |
267 | | detail::WinHandle h(path, DELETE, FILE_FLAG_OPEN_REPARSE_POINT); |
268 | | if (!h) |
269 | | return set_errno(); |
270 | | FILE_DISPOSITION_INFO info; |
271 | | info.DeleteFile = TRUE; |
272 | | if (!SetFileInformationByHandle(h, FileDispositionInfo, &info, sizeof(info))) |
273 | | return set_errno(); |
274 | | return 0; |
275 | | } |
276 | | |
277 | | int truncate_handle(HANDLE h, off_t length) { |
278 | | LARGE_INTEGER size_param; |
279 | | size_param.QuadPart = length; |
280 | | if (!SetFilePointerEx(h, size_param, 0, FILE_BEGIN)) |
281 | | return set_errno(); |
282 | | if (!SetEndOfFile(h)) |
283 | | return set_errno(); |
284 | | return 0; |
285 | | } |
286 | | |
287 | | int ftruncate(int fd, off_t length) { |
288 | | HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd)); |
289 | | return truncate_handle(h, length); |
290 | | } |
291 | | |
292 | | int truncate(const wchar_t *path, off_t length) { |
293 | | detail::WinHandle h(path, GENERIC_WRITE, 0); |
294 | | if (!h) |
295 | | return set_errno(); |
296 | | return truncate_handle(h, length); |
297 | | } |
298 | | |
299 | | int rename(const wchar_t *from, const wchar_t *to) { |
300 | | if (!(MoveFileExW(from, to, |
301 | | MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING | |
302 | | MOVEFILE_WRITE_THROUGH))) |
303 | | return set_errno(); |
304 | | return 0; |
305 | | } |
306 | | |
307 | | template <class... Args> int open(const wchar_t *filename, Args... args) { |
308 | | return _wopen(filename, args...); |
309 | | } |
310 | | int close(int fd) { return _close(fd); } |
311 | | int chdir(const wchar_t *path) { return _wchdir(path); } |
312 | | |
313 | | struct StatVFS { |
314 | | uint64_t f_frsize; |
315 | | uint64_t f_blocks; |
316 | | uint64_t f_bfree; |
317 | | uint64_t f_bavail; |
318 | | }; |
319 | | |
320 | | int statvfs(const wchar_t *p, StatVFS *buf) { |
321 | | path dir = p; |
322 | | while (true) { |
323 | | error_code local_ec; |
324 | | const file_status st = status(dir, local_ec); |
325 | | if (!exists(st) || is_directory(st)) |
326 | | break; |
327 | | path parent = dir.parent_path(); |
328 | | if (parent == dir) { |
329 | | errno = ENOENT; |
330 | | return -1; |
331 | | } |
332 | | dir = parent; |
333 | | } |
334 | | ULARGE_INTEGER free_bytes_available_to_caller, total_number_of_bytes, |
335 | | total_number_of_free_bytes; |
336 | | if (!GetDiskFreeSpaceExW(dir.c_str(), &free_bytes_available_to_caller, |
337 | | &total_number_of_bytes, &total_number_of_free_bytes)) |
338 | | return set_errno(); |
339 | | buf->f_frsize = 1; |
340 | | buf->f_blocks = total_number_of_bytes.QuadPart; |
341 | | buf->f_bfree = total_number_of_free_bytes.QuadPart; |
342 | | buf->f_bavail = free_bytes_available_to_caller.QuadPart; |
343 | | return 0; |
344 | | } |
345 | | |
346 | | wchar_t *getcwd(wchar_t *buff, size_t size) { return _wgetcwd(buff, size); } |
347 | | |
348 | | wchar_t *realpath(const wchar_t *path, wchar_t *resolved_name) { |
349 | | // Only expected to be used with us allocating the buffer. |
350 | | _LIBCPP_ASSERT(resolved_name == nullptr, |
351 | | "Windows realpath() assumes a null resolved_name"); |
352 | | |
353 | | WinHandle h(path, FILE_READ_ATTRIBUTES, 0); |
354 | | if (!h) { |
355 | | set_errno(); |
356 | | return nullptr; |
357 | | } |
358 | | size_t buff_size = MAX_PATH + 10; |
359 | | std::unique_ptr<wchar_t, decltype(&::free)> buff( |
360 | | static_cast<wchar_t *>(malloc(buff_size * sizeof(wchar_t))), &::free); |
361 | | DWORD retval = GetFinalPathNameByHandleW( |
362 | | h, buff.get(), buff_size, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS); |
363 | | if (retval > buff_size) { |
364 | | buff_size = retval; |
365 | | buff.reset(static_cast<wchar_t *>(malloc(buff_size * sizeof(wchar_t)))); |
366 | | retval = GetFinalPathNameByHandleW(h, buff.get(), buff_size, |
367 | | FILE_NAME_NORMALIZED | VOLUME_NAME_DOS); |
368 | | } |
369 | | if (!retval) { |
370 | | set_errno(); |
371 | | return nullptr; |
372 | | } |
373 | | wchar_t *ptr = buff.get(); |
374 | | if (!wcsncmp(ptr, L"\\\\?\\", 4)) { |
375 | | if (ptr[5] == ':') { // \\?\X: -> X: |
376 | | memmove(&ptr[0], &ptr[4], (wcslen(&ptr[4]) + 1) * sizeof(wchar_t)); |
377 | | } else if (!wcsncmp(&ptr[4], L"UNC\\", 4)) { // \\?\UNC\server -> \\server |
378 | | wcscpy(&ptr[0], L"\\\\"); |
379 | | memmove(&ptr[2], &ptr[8], (wcslen(&ptr[8]) + 1) * sizeof(wchar_t)); |
380 | | } |
381 | | } |
382 | | return buff.release(); |
383 | | } |
384 | | |
385 | | #define AT_FDCWD -1 |
386 | | #define AT_SYMLINK_NOFOLLOW 1 |
387 | | using ModeT = int; |
388 | | |
389 | | int fchmod_handle(HANDLE h, int perms) { |
390 | | FILE_BASIC_INFO basic; |
391 | | if (!GetFileInformationByHandleEx(h, FileBasicInfo, &basic, sizeof(basic))) |
392 | | return set_errno(); |
393 | | DWORD orig_attributes = basic.FileAttributes; |
394 | | basic.FileAttributes &= ~FILE_ATTRIBUTE_READONLY; |
395 | | if ((perms & 0222) == 0) |
396 | | basic.FileAttributes |= FILE_ATTRIBUTE_READONLY; |
397 | | if (basic.FileAttributes != orig_attributes && |
398 | | !SetFileInformationByHandle(h, FileBasicInfo, &basic, sizeof(basic))) |
399 | | return set_errno(); |
400 | | return 0; |
401 | | } |
402 | | |
403 | | int fchmodat(int fd, const wchar_t *path, int perms, int flag) { |
404 | | DWORD attributes = GetFileAttributesW(path); |
405 | | if (attributes == INVALID_FILE_ATTRIBUTES) |
406 | | return set_errno(); |
407 | | if (attributes & FILE_ATTRIBUTE_REPARSE_POINT && |
408 | | !(flag & AT_SYMLINK_NOFOLLOW)) { |
409 | | // If the file is a symlink, and we are supposed to operate on the target |
410 | | // of the symlink, we need to open a handle to it, without the |
411 | | // FILE_FLAG_OPEN_REPARSE_POINT flag, to open the destination of the |
412 | | // symlink, and operate on it via the handle. |
413 | | detail::WinHandle h(path, FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES, 0); |
414 | | if (!h) |
415 | | return set_errno(); |
416 | | return fchmod_handle(h, perms); |
417 | | } else { |
418 | | // For a non-symlink, or if operating on the symlink itself instead of |
419 | | // its target, we can use SetFileAttributesW, saving a few calls. |
420 | | DWORD orig_attributes = attributes; |
421 | | attributes &= ~FILE_ATTRIBUTE_READONLY; |
422 | | if ((perms & 0222) == 0) |
423 | | attributes |= FILE_ATTRIBUTE_READONLY; |
424 | | if (attributes != orig_attributes && !SetFileAttributesW(path, attributes)) |
425 | | return set_errno(); |
426 | | } |
427 | | return 0; |
428 | | } |
429 | | |
430 | | int fchmod(int fd, int perms) { |
431 | | HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd)); |
432 | | return fchmod_handle(h, perms); |
433 | | } |
434 | | |
435 | | #define MAX_SYMLINK_SIZE MAXIMUM_REPARSE_DATA_BUFFER_SIZE |
436 | | using SSizeT = ::int64_t; |
437 | | |
438 | | SSizeT readlink(const wchar_t *path, wchar_t *ret_buf, size_t bufsize) { |
439 | | uint8_t buf[MAXIMUM_REPARSE_DATA_BUFFER_SIZE]; |
440 | | detail::WinHandle h(path, FILE_READ_ATTRIBUTES, FILE_FLAG_OPEN_REPARSE_POINT); |
441 | | if (!h) |
442 | | return set_errno(); |
443 | | DWORD out; |
444 | | if (!DeviceIoControl(h, FSCTL_GET_REPARSE_POINT, nullptr, 0, buf, sizeof(buf), |
445 | | &out, 0)) |
446 | | return set_errno(); |
447 | | const auto *reparse = reinterpret_cast<LIBCPP_REPARSE_DATA_BUFFER *>(buf); |
448 | | size_t path_buf_offset = offsetof(LIBCPP_REPARSE_DATA_BUFFER, |
449 | | SymbolicLinkReparseBuffer.PathBuffer[0]); |
450 | | if (out < path_buf_offset) { |
451 | | errno = EINVAL; |
452 | | return -1; |
453 | | } |
454 | | if (reparse->ReparseTag != IO_REPARSE_TAG_SYMLINK) { |
455 | | errno = EINVAL; |
456 | | return -1; |
457 | | } |
458 | | const auto &symlink = reparse->SymbolicLinkReparseBuffer; |
459 | | unsigned short name_offset, name_length; |
460 | | if (symlink.PrintNameLength == 0) { |
461 | | name_offset = symlink.SubstituteNameOffset; |
462 | | name_length = symlink.SubstituteNameLength; |
463 | | } else { |
464 | | name_offset = symlink.PrintNameOffset; |
465 | | name_length = symlink.PrintNameLength; |
466 | | } |
467 | | // name_offset/length are expressed in bytes, not in wchar_t |
468 | | if (path_buf_offset + name_offset + name_length > out) { |
469 | | errno = EINVAL; |
470 | | return -1; |
471 | | } |
472 | | if (name_length / sizeof(wchar_t) > bufsize) { |
473 | | errno = ENOMEM; |
474 | | return -1; |
475 | | } |
476 | | memcpy(ret_buf, &symlink.PathBuffer[name_offset / sizeof(wchar_t)], |
477 | | name_length); |
478 | | return name_length / sizeof(wchar_t); |
479 | | } |
480 | | |
481 | | #else |
482 | 0 | int symlink_file(const char *oldname, const char *newname) { |
483 | 0 | return ::symlink(oldname, newname); |
484 | 0 | } |
485 | 0 | int symlink_dir(const char *oldname, const char *newname) { |
486 | 0 | return ::symlink(oldname, newname); |
487 | 0 | } |
488 | | using ::chdir; |
489 | | using ::close; |
490 | | using ::fchmod; |
491 | | #if defined(AT_SYMLINK_NOFOLLOW) && defined(AT_FDCWD) |
492 | | using ::fchmodat; |
493 | | #endif |
494 | | using ::fstat; |
495 | | using ::ftruncate; |
496 | | using ::getcwd; |
497 | | using ::link; |
498 | | using ::lstat; |
499 | | using ::mkdir; |
500 | | using ::open; |
501 | | using ::readlink; |
502 | | using ::realpath; |
503 | | using ::remove; |
504 | | using ::rename; |
505 | | using ::stat; |
506 | | using ::statvfs; |
507 | | using ::truncate; |
508 | | |
509 | 0 | #define O_BINARY 0 |
510 | | |
511 | | using StatVFS = struct statvfs; |
512 | | using ModeT = ::mode_t; |
513 | | using SSizeT = ::ssize_t; |
514 | | |
515 | | #endif |
516 | | |
517 | | } // namespace |
518 | | } // end namespace detail |
519 | | |
520 | | _LIBCPP_END_NAMESPACE_FILESYSTEM |
521 | | |
522 | | #endif // POSIX_COMPAT_H |