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 #ifndef FILESYSTEM_COMMON_H
10 #define FILESYSTEM_COMMON_H
11
12 #include "__config"
13 #include "filesystem"
14 #include "array"
15 #include "chrono"
16 #include "cstdlib"
17 #include "climits"
18
19 #include <unistd.h>
20 #include <sys/stat.h>
21 #include <sys/statvfs.h>
22 #include <sys/time.h> // for ::utimes as used in __last_write_time
23 #include <fcntl.h> /* values for fchmodat */
24
25 #include "../include/apple_availability.h"
26
27 #if !defined(__APPLE__)
28 // We can use the presence of UTIME_OMIT to detect platforms that provide
29 // utimensat.
30 #if defined(UTIME_OMIT)
31 #define _LIBCPP_USE_UTIMENSAT
32 #endif
33 #endif
34
35 #if defined(__GNUC__)
36 #pragma GCC diagnostic push
37 #pragma GCC diagnostic ignored "-Wunused-function"
38 #endif
39
40 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
41
42 namespace detail {
43 namespace {
44
format_string_imp(const char * msg,...)45 static string format_string_imp(const char* msg, ...) {
46 // we might need a second shot at this, so pre-emptivly make a copy
47 struct GuardVAList {
48 va_list& target;
49 bool active = true;
50 GuardVAList(va_list& target) : target(target), active(true) {}
51 void clear() {
52 if (active)
53 va_end(target);
54 active = false;
55 }
56 ~GuardVAList() {
57 if (active)
58 va_end(target);
59 }
60 };
61 va_list args;
62 va_start(args, msg);
63 GuardVAList args_guard(args);
64
65 va_list args_cp;
66 va_copy(args_cp, args);
67 GuardVAList args_copy_guard(args_cp);
68
69 std::string result;
70
71 array<char, 256> local_buff;
72 size_t size_with_null = local_buff.size();
73 auto ret = ::vsnprintf(local_buff.data(), size_with_null, msg, args_cp);
74
75 args_copy_guard.clear();
76
77 // handle empty expansion
78 if (ret == 0)
79 return result;
80 if (static_cast<size_t>(ret) < size_with_null) {
81 result.assign(local_buff.data(), static_cast<size_t>(ret));
82 return result;
83 }
84
85 // we did not provide a long enough buffer on our first attempt. The
86 // return value is the number of bytes (excluding the null byte) that are
87 // needed for formatting.
88 size_with_null = static_cast<size_t>(ret) + 1;
89 result.__resize_default_init(size_with_null - 1);
90 ret = ::vsnprintf(&result[0], size_with_null, msg, args);
91 _LIBCPP_ASSERT(static_cast<size_t>(ret) == (size_with_null - 1), "TODO");
92
93 return result;
94 }
95
unwrap(string const & s)96 const char* unwrap(string const& s) { return s.c_str(); }
unwrap(path const & p)97 const char* unwrap(path const& p) { return p.native().c_str(); }
98 template <class Arg>
unwrap(Arg const & a)99 Arg const& unwrap(Arg const& a) {
100 static_assert(!is_class<Arg>::value, "cannot pass class here");
101 return a;
102 }
103
104 template <class... Args>
format_string(const char * fmt,Args const &...args)105 string format_string(const char* fmt, Args const&... args) {
106 return format_string_imp(fmt, unwrap(args)...);
107 }
108
capture_errno()109 error_code capture_errno() {
110 _LIBCPP_ASSERT(errno, "Expected errno to be non-zero");
111 return error_code(errno, generic_category());
112 }
113
114 template <class T>
115 T error_value();
116 template <>
117 _LIBCPP_CONSTEXPR_AFTER_CXX11 void error_value<void>() {}
118 template <>
119 bool error_value<bool>() {
120 return false;
121 }
122 template <>
123 uintmax_t error_value<uintmax_t>() {
124 return uintmax_t(-1);
125 }
126 template <>
127 _LIBCPP_CONSTEXPR_AFTER_CXX11 file_time_type error_value<file_time_type>() {
128 return file_time_type::min();
129 }
130 template <>
131 path error_value<path>() {
132 return {};
133 }
134
135 template <class T>
136 struct ErrorHandler {
137 const char* func_name;
138 error_code* ec = nullptr;
139 const path* p1 = nullptr;
140 const path* p2 = nullptr;
141
142 ErrorHandler(const char* fname, error_code* ec, const path* p1 = nullptr,
143 const path* p2 = nullptr)
func_nameErrorHandler144 : func_name(fname), ec(ec), p1(p1), p2(p2) {
145 if (ec)
146 ec->clear();
147 }
148
reportErrorHandler149 T report(const error_code& m_ec) const {
150 if (ec) {
151 *ec = m_ec;
152 return error_value<T>();
153 }
154 string what = string("in ") + func_name;
155 switch (bool(p1) + bool(p2)) {
156 case 0:
157 __throw_filesystem_error(what, m_ec);
158 case 1:
159 __throw_filesystem_error(what, *p1, m_ec);
160 case 2:
161 __throw_filesystem_error(what, *p1, *p2, m_ec);
162 }
163 _LIBCPP_UNREACHABLE();
164 }
165
166 template <class... Args>
reportErrorHandler167 T report(const error_code& m_ec, const char* msg, Args const&... args) const {
168 if (ec) {
169 *ec = m_ec;
170 return error_value<T>();
171 }
172 string what =
173 string("in ") + func_name + ": " + format_string(msg, args...);
174 switch (bool(p1) + bool(p2)) {
175 case 0:
176 __throw_filesystem_error(what, m_ec);
177 case 1:
178 __throw_filesystem_error(what, *p1, m_ec);
179 case 2:
180 __throw_filesystem_error(what, *p1, *p2, m_ec);
181 }
182 _LIBCPP_UNREACHABLE();
183 }
184
reportErrorHandler185 T report(errc const& err) const { return report(make_error_code(err)); }
186
187 template <class... Args>
reportErrorHandler188 T report(errc const& err, const char* msg, Args const&... args) const {
189 return report(make_error_code(err), msg, args...);
190 }
191
192 private:
193 ErrorHandler(ErrorHandler const&) = delete;
194 ErrorHandler& operator=(ErrorHandler const&) = delete;
195 };
196
197 using chrono::duration;
198 using chrono::duration_cast;
199
200 using TimeSpec = struct ::timespec;
201 using StatT = struct ::stat;
202
203 template <class FileTimeT, class TimeT,
204 bool IsFloat = is_floating_point<typename FileTimeT::rep>::value>
205 struct time_util_base {
206 using rep = typename FileTimeT::rep;
207 using fs_duration = typename FileTimeT::duration;
208 using fs_seconds = duration<rep>;
209 using fs_nanoseconds = duration<rep, nano>;
210 using fs_microseconds = duration<rep, micro>;
211
212 static constexpr rep max_seconds =
213 duration_cast<fs_seconds>(FileTimeT::duration::max()).count();
214
215 static constexpr rep max_nsec =
216 duration_cast<fs_nanoseconds>(FileTimeT::duration::max() -
217 fs_seconds(max_seconds))
218 .count();
219
220 static constexpr rep min_seconds =
221 duration_cast<fs_seconds>(FileTimeT::duration::min()).count();
222
223 static constexpr rep min_nsec_timespec =
224 duration_cast<fs_nanoseconds>(
225 (FileTimeT::duration::min() - fs_seconds(min_seconds)) +
226 fs_seconds(1))
227 .count();
228
229 private:
230 #if _LIBCPP_STD_VER > 11 && !defined(_LIBCPP_HAS_NO_CXX14_CONSTEXPR)
get_min_nsecstime_util_base231 static constexpr fs_duration get_min_nsecs() {
232 return duration_cast<fs_duration>(
233 fs_nanoseconds(min_nsec_timespec) -
234 duration_cast<fs_nanoseconds>(fs_seconds(1)));
235 }
236 // Static assert that these values properly round trip.
237 static_assert(fs_seconds(min_seconds) + get_min_nsecs() ==
238 FileTimeT::duration::min(),
239 "value doesn't roundtrip");
240
check_rangetime_util_base241 static constexpr bool check_range() {
242 // This kinda sucks, but it's what happens when we don't have __int128_t.
243 if (sizeof(TimeT) == sizeof(rep)) {
244 typedef duration<long long, ratio<3600 * 24 * 365> > Years;
245 return duration_cast<Years>(fs_seconds(max_seconds)) > Years(250) &&
246 duration_cast<Years>(fs_seconds(min_seconds)) < Years(-250);
247 }
248 return max_seconds >= numeric_limits<TimeT>::max() &&
249 min_seconds <= numeric_limits<TimeT>::min();
250 }
251 static_assert(check_range(), "the representable range is unacceptable small");
252 #endif
253 };
254
255 template <class FileTimeT, class TimeT>
256 struct time_util_base<FileTimeT, TimeT, true> {
257 using rep = typename FileTimeT::rep;
258 using fs_duration = typename FileTimeT::duration;
259 using fs_seconds = duration<rep>;
260 using fs_nanoseconds = duration<rep, nano>;
261 using fs_microseconds = duration<rep, micro>;
262
263 static const rep max_seconds;
264 static const rep max_nsec;
265 static const rep min_seconds;
266 static const rep min_nsec_timespec;
267 };
268
269 template <class FileTimeT, class TimeT>
270 const typename FileTimeT::rep
271 time_util_base<FileTimeT, TimeT, true>::max_seconds =
272 duration_cast<fs_seconds>(FileTimeT::duration::max()).count();
273
274 template <class FileTimeT, class TimeT>
275 const typename FileTimeT::rep time_util_base<FileTimeT, TimeT, true>::max_nsec =
276 duration_cast<fs_nanoseconds>(FileTimeT::duration::max() -
277 fs_seconds(max_seconds))
278 .count();
279
280 template <class FileTimeT, class TimeT>
281 const typename FileTimeT::rep
282 time_util_base<FileTimeT, TimeT, true>::min_seconds =
283 duration_cast<fs_seconds>(FileTimeT::duration::min()).count();
284
285 template <class FileTimeT, class TimeT>
286 const typename FileTimeT::rep
287 time_util_base<FileTimeT, TimeT, true>::min_nsec_timespec =
288 duration_cast<fs_nanoseconds>((FileTimeT::duration::min() -
289 fs_seconds(min_seconds)) +
290 fs_seconds(1))
291 .count();
292
293 template <class FileTimeT, class TimeT, class TimeSpecT>
294 struct time_util : time_util_base<FileTimeT, TimeT> {
295 using Base = time_util_base<FileTimeT, TimeT>;
296 using Base::max_nsec;
297 using Base::max_seconds;
298 using Base::min_nsec_timespec;
299 using Base::min_seconds;
300
301 using typename Base::fs_duration;
302 using typename Base::fs_microseconds;
303 using typename Base::fs_nanoseconds;
304 using typename Base::fs_seconds;
305
306 public:
307 template <class CType, class ChronoType>
308 static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool checked_set(CType* out,
309 ChronoType time) {
310 using Lim = numeric_limits<CType>;
311 if (time > Lim::max() || time < Lim::min())
312 return false;
313 *out = static_cast<CType>(time);
314 return true;
315 }
316
317 static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool is_representable(TimeSpecT tm) {
318 if (tm.tv_sec >= 0) {
319 return tm.tv_sec < max_seconds ||
320 (tm.tv_sec == max_seconds && tm.tv_nsec <= max_nsec);
321 } else if (tm.tv_sec == (min_seconds - 1)) {
322 return tm.tv_nsec >= min_nsec_timespec;
323 } else {
324 return tm.tv_sec >= min_seconds;
325 }
326 }
327
328 static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool is_representable(FileTimeT tm) {
329 auto secs = duration_cast<fs_seconds>(tm.time_since_epoch());
330 auto nsecs = duration_cast<fs_nanoseconds>(tm.time_since_epoch() - secs);
331 if (nsecs.count() < 0) {
332 secs = secs + fs_seconds(1);
333 nsecs = nsecs + fs_seconds(1);
334 }
335 using TLim = numeric_limits<TimeT>;
336 if (secs.count() >= 0)
337 return secs.count() <= TLim::max();
338 return secs.count() >= TLim::min();
339 }
340
341 static _LIBCPP_CONSTEXPR_AFTER_CXX11 FileTimeT
342 convert_from_timespec(TimeSpecT tm) {
343 if (tm.tv_sec >= 0 || tm.tv_nsec == 0) {
344 return FileTimeT(fs_seconds(tm.tv_sec) +
345 duration_cast<fs_duration>(fs_nanoseconds(tm.tv_nsec)));
346 } else { // tm.tv_sec < 0
347 auto adj_subsec = duration_cast<fs_duration>(fs_seconds(1) -
348 fs_nanoseconds(tm.tv_nsec));
349 auto Dur = fs_seconds(tm.tv_sec + 1) - adj_subsec;
350 return FileTimeT(Dur);
351 }
352 }
353
354 template <class SubSecT>
355 static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool
356 set_times_checked(TimeT* sec_out, SubSecT* subsec_out, FileTimeT tp) {
357 auto dur = tp.time_since_epoch();
358 auto sec_dur = duration_cast<fs_seconds>(dur);
359 auto subsec_dur = duration_cast<fs_nanoseconds>(dur - sec_dur);
360 // The tv_nsec and tv_usec fields must not be negative so adjust accordingly
361 if (subsec_dur.count() < 0) {
362 if (sec_dur.count() > min_seconds) {
363 sec_dur = sec_dur - fs_seconds(1);
364 subsec_dur = subsec_dur + fs_seconds(1);
365 } else {
366 subsec_dur = fs_nanoseconds::zero();
367 }
368 }
369 return checked_set(sec_out, sec_dur.count()) &&
370 checked_set(subsec_out, subsec_dur.count());
371 }
372 static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool convert_to_timespec(TimeSpecT& dest,
373 FileTimeT tp) {
374 if (!is_representable(tp))
375 return false;
376 return set_times_checked(&dest.tv_sec, &dest.tv_nsec, tp);
377 }
378 };
379
380 using fs_time = time_util<file_time_type, time_t, TimeSpec>;
381
382 #if defined(__APPLE__)
383 TimeSpec extract_mtime(StatT const& st) { return st.st_mtimespec; }
384 TimeSpec extract_atime(StatT const& st) { return st.st_atimespec; }
385 #else
386 TimeSpec extract_mtime(StatT const& st) { return st.st_mtim; }
387 TimeSpec extract_atime(StatT const& st) { return st.st_atim; }
388 #endif
389
390 // allow the utimes implementation to compile even it we're not going
391 // to use it.
392
393 bool posix_utimes(const path& p, std::array<TimeSpec, 2> const& TS,
394 error_code& ec) {
395 using namespace chrono;
396 auto Convert = [](long nsec) {
397 using int_type = decltype(std::declval< ::timeval>().tv_usec);
398 auto dur = duration_cast<microseconds>(nanoseconds(nsec)).count();
399 return static_cast<int_type>(dur);
400 };
401 struct ::timeval ConvertedTS[2] = {{TS[0].tv_sec, Convert(TS[0].tv_nsec)},
402 {TS[1].tv_sec, Convert(TS[1].tv_nsec)}};
403 if (::utimes(p.c_str(), ConvertedTS) == -1) {
404 ec = capture_errno();
405 return true;
406 }
407 return false;
408 }
409
410 #if defined(_LIBCPP_USE_UTIMENSAT)
411 bool posix_utimensat(const path& p, std::array<TimeSpec, 2> const& TS,
412 error_code& ec) {
413 if (::utimensat(AT_FDCWD, p.c_str(), TS.data(), 0) == -1) {
414 ec = capture_errno();
415 return true;
416 }
417 return false;
418 }
419 #endif
420
421 bool set_file_times(const path& p, std::array<TimeSpec, 2> const& TS,
422 error_code& ec) {
423 #if !defined(_LIBCPP_USE_UTIMENSAT)
424 return posix_utimes(p, TS, ec);
425 #else
426 return posix_utimensat(p, TS, ec);
427 #endif
428 }
429
430 } // namespace
431 } // end namespace detail
432
433 _LIBCPP_END_NAMESPACE_FILESYSTEM
434
435 #endif // FILESYSTEM_COMMON_H
436