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_TIME_UTILS_H
10 #define FILESYSTEM_TIME_UTILS_H
11
12 #include <__config>
13 #include <array>
14 #include <chrono>
15 #include <filesystem>
16 #include <limits>
17 #include <ratio>
18 #include <system_error>
19 #include <type_traits>
20 #include <utility>
21
22 #include "error.h"
23 #include "format_string.h"
24
25 #if defined(_LIBCPP_WIN32API)
26 # define WIN32_LEAN_AND_MEAN
27 # define NOMINMAX
28 # include <windows.h>
29 #else
30 # include <fcntl.h>
31 # include <sys/stat.h>
32 # include <sys/time.h> // for ::utimes as used in __last_write_time
33 #endif
34
35 // We can use the presence of UTIME_OMIT to detect platforms that provide utimensat.
36 #if defined(UTIME_OMIT)
37 # define _LIBCPP_USE_UTIMENSAT
38 #endif
39
40 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
41
42 namespace detail {
43
44 #if defined(_LIBCPP_WIN32API)
45 // Various C runtime versions (UCRT, or the legacy msvcrt.dll used by
46 // some mingw toolchains) provide different stat function implementations,
47 // with a number of limitations with respect to what we want from the
48 // stat function. Instead provide our own which does exactly what we want,
49 // along with our own stat structure and flag macros.
50
51 struct TimeSpec {
52 int64_t tv_sec;
53 int64_t tv_nsec;
54 };
55 struct StatT {
56 unsigned st_mode;
57 TimeSpec st_atim;
58 TimeSpec st_mtim;
59 uint64_t st_dev; // FILE_ID_INFO::VolumeSerialNumber
60 struct FileIdStruct {
61 unsigned char id[16]; // FILE_ID_INFO::FileId
62 bool operator==(const FileIdStruct& other) const {
63 for (int i = 0; i < 16; i++)
64 if (id[i] != other.id[i])
65 return false;
66 return true;
67 }
68 } st_ino;
69 uint32_t st_nlink;
70 uintmax_t st_size;
71 };
72
73 // There were 369 years and 89 leap days from the Windows epoch
74 // (1601) to the Unix epoch (1970).
75 # define FILE_TIME_OFFSET_SECS (uint64_t(369 * 365 + 89) * (24 * 60 * 60))
76
filetime_to_timespec(LARGE_INTEGER li)77 inline TimeSpec filetime_to_timespec(LARGE_INTEGER li) {
78 TimeSpec ret;
79 ret.tv_sec = li.QuadPart / 10000000 - FILE_TIME_OFFSET_SECS;
80 ret.tv_nsec = (li.QuadPart % 10000000) * 100;
81 return ret;
82 }
83
filetime_to_timespec(FILETIME ft)84 inline TimeSpec filetime_to_timespec(FILETIME ft) {
85 LARGE_INTEGER li;
86 li.LowPart = ft.dwLowDateTime;
87 li.HighPart = ft.dwHighDateTime;
88 return filetime_to_timespec(li);
89 }
90
timespec_to_filetime(TimeSpec ts)91 inline FILETIME timespec_to_filetime(TimeSpec ts) {
92 LARGE_INTEGER li;
93 li.QuadPart = ts.tv_nsec / 100 + (ts.tv_sec + FILE_TIME_OFFSET_SECS) * 10000000;
94 FILETIME ft;
95 ft.dwLowDateTime = li.LowPart;
96 ft.dwHighDateTime = li.HighPart;
97 return ft;
98 }
99
100 #else
101 using TimeSpec = struct timespec;
102 using TimeVal = struct timeval;
103 using StatT = struct stat;
104
105 inline TimeVal make_timeval(TimeSpec const& ts) {
106 using namespace chrono;
107 auto Convert = [](long nsec) {
108 using int_type = decltype(std::declval<TimeVal>().tv_usec);
109 auto dur = duration_cast<microseconds>(nanoseconds(nsec)).count();
110 return static_cast<int_type>(dur);
111 };
112 TimeVal TV = {};
113 TV.tv_sec = ts.tv_sec;
114 TV.tv_usec = Convert(ts.tv_nsec);
115 return TV;
116 }
117 #endif
118
119 using chrono::duration;
120 using chrono::duration_cast;
121
122 template <class FileTimeT, class TimeT, bool IsFloat = is_floating_point<typename FileTimeT::rep>::value>
123 struct time_util_base {
124 using rep = typename FileTimeT::rep;
125 using fs_duration = typename FileTimeT::duration;
126 using fs_seconds = duration<rep>;
127 using fs_nanoseconds = duration<rep, nano>;
128 using fs_microseconds = duration<rep, micro>;
129
130 static constexpr rep max_seconds = duration_cast<fs_seconds>(FileTimeT::duration::max()).count();
131
132 static constexpr rep max_nsec =
133 duration_cast<fs_nanoseconds>(FileTimeT::duration::max() - fs_seconds(max_seconds)).count();
134
135 static constexpr rep min_seconds = duration_cast<fs_seconds>(FileTimeT::duration::min()).count();
136
137 static constexpr rep min_nsec_timespec =
138 duration_cast<fs_nanoseconds>((FileTimeT::duration::min() - fs_seconds(min_seconds)) + fs_seconds(1)).count();
139
140 private:
get_min_nsecstime_util_base141 static constexpr fs_duration get_min_nsecs() {
142 return duration_cast<fs_duration>(fs_nanoseconds(min_nsec_timespec) - duration_cast<fs_nanoseconds>(fs_seconds(1)));
143 }
144 // Static assert that these values properly round trip.
145 static_assert(fs_seconds(min_seconds) + get_min_nsecs() == FileTimeT::duration::min(), "value doesn't roundtrip");
146
check_rangetime_util_base147 static constexpr bool check_range() {
148 // This kinda sucks, but it's what happens when we don't have __int128_t.
149 if (sizeof(TimeT) == sizeof(rep)) {
150 typedef duration<long long, ratio<3600 * 24 * 365> > Years;
151 return duration_cast<Years>(fs_seconds(max_seconds)) > Years(250) &&
152 duration_cast<Years>(fs_seconds(min_seconds)) < Years(-250);
153 }
154 return max_seconds >= numeric_limits<TimeT>::max() && min_seconds <= numeric_limits<TimeT>::min();
155 }
156 #if _LIBCPP_STD_VER >= 14
157 static_assert(check_range(), "the representable range is unacceptable small");
158 #endif
159 };
160
161 template <class FileTimeT, class TimeT>
162 struct time_util_base<FileTimeT, TimeT, true> {
163 using rep = typename FileTimeT::rep;
164 using fs_duration = typename FileTimeT::duration;
165 using fs_seconds = duration<rep>;
166 using fs_nanoseconds = duration<rep, nano>;
167 using fs_microseconds = duration<rep, micro>;
168
169 static const rep max_seconds;
170 static const rep max_nsec;
171 static const rep min_seconds;
172 static const rep min_nsec_timespec;
173 };
174
175 template <class FileTimeT, class TimeT>
176 const typename FileTimeT::rep time_util_base<FileTimeT, TimeT, true>::max_seconds =
177 duration_cast<fs_seconds>(FileTimeT::duration::max()).count();
178
179 template <class FileTimeT, class TimeT>
180 const typename FileTimeT::rep time_util_base<FileTimeT, TimeT, true>::max_nsec =
181 duration_cast<fs_nanoseconds>(FileTimeT::duration::max() - fs_seconds(max_seconds)).count();
182
183 template <class FileTimeT, class TimeT>
184 const typename FileTimeT::rep time_util_base<FileTimeT, TimeT, true>::min_seconds =
185 duration_cast<fs_seconds>(FileTimeT::duration::min()).count();
186
187 template <class FileTimeT, class TimeT>
188 const typename FileTimeT::rep time_util_base<FileTimeT, TimeT, true>::min_nsec_timespec =
189 duration_cast<fs_nanoseconds>((FileTimeT::duration::min() - fs_seconds(min_seconds)) + fs_seconds(1)).count();
190
191 template <class FileTimeT, class TimeT, class TimeSpecT>
192 struct time_util : time_util_base<FileTimeT, TimeT> {
193 using Base = time_util_base<FileTimeT, TimeT>;
194 using Base::max_nsec;
195 using Base::max_seconds;
196 using Base::min_nsec_timespec;
197 using Base::min_seconds;
198
199 using typename Base::fs_duration;
200 using typename Base::fs_microseconds;
201 using typename Base::fs_nanoseconds;
202 using typename Base::fs_seconds;
203
204 public:
205 template <class CType, class ChronoType>
206 static constexpr bool checked_set(CType* out, ChronoType time) {
207 using Lim = numeric_limits<CType>;
208 if (time > Lim::max() || time < Lim::min())
209 return false;
210 *out = static_cast<CType>(time);
211 return true;
212 }
213
214 static constexpr bool is_representable(TimeSpecT tm) {
215 if (tm.tv_sec >= 0) {
216 return tm.tv_sec < max_seconds || (tm.tv_sec == max_seconds && tm.tv_nsec <= max_nsec);
217 } else if (tm.tv_sec == (min_seconds - 1)) {
218 return tm.tv_nsec >= min_nsec_timespec;
219 } else {
220 return tm.tv_sec >= min_seconds;
221 }
222 }
223
224 static constexpr bool is_representable(FileTimeT tm) {
225 auto secs = duration_cast<fs_seconds>(tm.time_since_epoch());
226 auto nsecs = duration_cast<fs_nanoseconds>(tm.time_since_epoch() - secs);
227 if (nsecs.count() < 0) {
228 secs = secs + fs_seconds(1);
229 nsecs = nsecs + fs_seconds(1);
230 }
231 using TLim = numeric_limits<TimeT>;
232 if (secs.count() >= 0)
233 return secs.count() <= TLim::max();
234 return secs.count() >= TLim::min();
235 }
236
237 static constexpr FileTimeT convert_from_timespec(TimeSpecT tm) {
238 if (tm.tv_sec >= 0 || tm.tv_nsec == 0) {
239 return FileTimeT(fs_seconds(tm.tv_sec) + duration_cast<fs_duration>(fs_nanoseconds(tm.tv_nsec)));
240 } else { // tm.tv_sec < 0
241 auto adj_subsec = duration_cast<fs_duration>(fs_seconds(1) - fs_nanoseconds(tm.tv_nsec));
242 auto Dur = fs_seconds(tm.tv_sec + 1) - adj_subsec;
243 return FileTimeT(Dur);
244 }
245 }
246
247 template <class SubSecT>
248 static constexpr bool set_times_checked(TimeT* sec_out, SubSecT* subsec_out, FileTimeT tp) {
249 auto dur = tp.time_since_epoch();
250 auto sec_dur = duration_cast<fs_seconds>(dur);
251 auto subsec_dur = duration_cast<fs_nanoseconds>(dur - sec_dur);
252 // The tv_nsec and tv_usec fields must not be negative so adjust accordingly
253 if (subsec_dur.count() < 0) {
254 if (sec_dur.count() > min_seconds) {
255 sec_dur = sec_dur - fs_seconds(1);
256 subsec_dur = subsec_dur + fs_seconds(1);
257 } else {
258 subsec_dur = fs_nanoseconds::zero();
259 }
260 }
261 return checked_set(sec_out, sec_dur.count()) && checked_set(subsec_out, subsec_dur.count());
262 }
263 static constexpr bool convert_to_timespec(TimeSpecT& dest, FileTimeT tp) {
264 if (!is_representable(tp))
265 return false;
266 return set_times_checked(&dest.tv_sec, &dest.tv_nsec, tp);
267 }
268 };
269
270 #if defined(_LIBCPP_WIN32API)
271 using fs_time = time_util<file_time_type, int64_t, TimeSpec>;
272 #else
273 using fs_time = time_util<file_time_type, time_t, TimeSpec>;
274 #endif
275
276 #if defined(__APPLE__)
277 inline TimeSpec extract_mtime(StatT const& st) { return st.st_mtimespec; }
278 inline TimeSpec extract_atime(StatT const& st) { return st.st_atimespec; }
279 #elif defined(__MVS__)
280 inline TimeSpec extract_mtime(StatT const& st) {
281 TimeSpec TS = {st.st_mtime, 0};
282 return TS;
283 }
284 inline TimeSpec extract_atime(StatT const& st) {
285 TimeSpec TS = {st.st_atime, 0};
286 return TS;
287 }
288 #elif defined(_AIX)
289 inline TimeSpec extract_mtime(StatT const& st) {
290 TimeSpec TS = {st.st_mtime, st.st_mtime_n};
291 return TS;
292 }
293 inline TimeSpec extract_atime(StatT const& st) {
294 TimeSpec TS = {st.st_atime, st.st_atime_n};
295 return TS;
296 }
297 #else
298 inline TimeSpec extract_mtime(StatT const& st) { return st.st_mtim; }
299 inline TimeSpec extract_atime(StatT const& st) { return st.st_atim; }
300 #endif
301
302 #ifndef _LIBCPP_HAS_NO_FILESYSTEM
303
304 # if !defined(_LIBCPP_WIN32API)
305 inline bool posix_utimes(const path& p, std::array<TimeSpec, 2> const& TS, error_code& ec) {
306 TimeVal ConvertedTS[2] = {make_timeval(TS[0]), make_timeval(TS[1])};
307 if (::utimes(p.c_str(), ConvertedTS) == -1) {
308 ec = capture_errno();
309 return true;
310 }
311 return false;
312 }
313
314 # if defined(_LIBCPP_USE_UTIMENSAT)
315 inline bool posix_utimensat(const path& p, std::array<TimeSpec, 2> const& TS, error_code& ec) {
316 if (::utimensat(AT_FDCWD, p.c_str(), TS.data(), 0) == -1) {
317 ec = capture_errno();
318 return true;
319 }
320 return false;
321 }
322 # endif
323
324 inline bool set_file_times(const path& p, std::array<TimeSpec, 2> const& TS, error_code& ec) {
325 # if !defined(_LIBCPP_USE_UTIMENSAT)
326 return posix_utimes(p, TS, ec);
327 # else
328 return posix_utimensat(p, TS, ec);
329 # endif
330 }
331
332 # endif // !_LIBCPP_WIN32API
333
334 inline file_time_type __extract_last_write_time(const path& p, const StatT& st, error_code* ec) {
335 using detail::fs_time;
336 ErrorHandler<file_time_type> err("last_write_time", ec, &p);
337
338 auto ts = detail::extract_mtime(st);
339 if (!fs_time::is_representable(ts))
340 return err.report(errc::value_too_large);
341
342 return fs_time::convert_from_timespec(ts);
343 }
344
345 #endif // !_LIBCPP_HAS_NO_FILESYSTEM
346
347 } // end namespace detail
348
349 _LIBCPP_END_NAMESPACE_FILESYSTEM
350
351 #endif // FILESYSTEM_TIME_UTILS_H
352