352 lines · c
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-exception6//7//===----------------------------------------------------------------------===////8 9#ifndef FILESYSTEM_TIME_UTILS_H10#define FILESYSTEM_TIME_UTILS_H11 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_MEAN27# define NOMINMAX28# include <windows.h>29#else30# include <fcntl.h>31# include <sys/stat.h>32# include <sys/time.h> // for ::utimes as used in __last_write_time33#endif34 35// We can use the presence of UTIME_OMIT to detect platforms that provide utimensat.36#if defined(UTIME_OMIT)37# define _LIBCPP_USE_UTIMENSAT38#endif39 40_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM41 42namespace detail {43 44#if defined(_LIBCPP_WIN32API)45// Various C runtime versions (UCRT, or the legacy msvcrt.dll used by46// some mingw toolchains) provide different stat function implementations,47// with a number of limitations with respect to what we want from the48// stat function. Instead provide our own which does exactly what we want,49// along with our own stat structure and flag macros.50 51struct TimeSpec {52 int64_t tv_sec;53 int64_t tv_nsec;54};55struct StatT {56 unsigned st_mode;57 TimeSpec st_atim;58 TimeSpec st_mtim;59 uint64_t st_dev; // FILE_ID_INFO::VolumeSerialNumber60 struct FileIdStruct {61 unsigned char id[16]; // FILE_ID_INFO::FileId62 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 epoch74// (1601) to the Unix epoch (1970).75# define FILE_TIME_OFFSET_SECS (uint64_t(369 * 365 + 89) * (24 * 60 * 60))76 77inline 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 84inline 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 91inline 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#else101using TimeSpec = struct timespec;102using TimeVal = struct timeval;103using StatT = struct stat;104 105inline 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#endif118 119using chrono::duration;120using chrono::duration_cast;121 122template <class FileTimeT, class TimeT, bool IsFloat = is_floating_point<typename FileTimeT::rep>::value>123struct 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 140private:141 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 147 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 >= 14157 static_assert(check_range(), "the representable range is unacceptable small");158#endif159};160 161template <class FileTimeT, class TimeT>162struct 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 175template <class FileTimeT, class TimeT>176const typename FileTimeT::rep time_util_base<FileTimeT, TimeT, true>::max_seconds =177 duration_cast<fs_seconds>(FileTimeT::duration::max()).count();178 179template <class FileTimeT, class TimeT>180const 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 183template <class FileTimeT, class TimeT>184const typename FileTimeT::rep time_util_base<FileTimeT, TimeT, true>::min_seconds =185 duration_cast<fs_seconds>(FileTimeT::duration::min()).count();186 187template <class FileTimeT, class TimeT>188const 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 191template <class FileTimeT, class TimeT, class TimeSpecT>192struct 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 204public: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 < 0241 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 accordingly253 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)271using fs_time = time_util<file_time_type, int64_t, TimeSpec>;272#else273using fs_time = time_util<file_time_type, time_t, TimeSpec>;274#endif275 276#if defined(__APPLE__)277inline TimeSpec extract_mtime(StatT const& st) { return st.st_mtimespec; }278inline TimeSpec extract_atime(StatT const& st) { return st.st_atimespec; }279#elif defined(__MVS__)280inline TimeSpec extract_mtime(StatT const& st) {281 TimeSpec TS = {st.st_mtime, 0};282 return TS;283}284inline TimeSpec extract_atime(StatT const& st) {285 TimeSpec TS = {st.st_atime, 0};286 return TS;287}288#elif defined(_AIX)289inline TimeSpec extract_mtime(StatT const& st) {290 TimeSpec TS = {st.st_mtime, st.st_mtime_n};291 return TS;292}293inline TimeSpec extract_atime(StatT const& st) {294 TimeSpec TS = {st.st_atime, st.st_atime_n};295 return TS;296}297#else298inline TimeSpec extract_mtime(StatT const& st) { return st.st_mtim; }299inline TimeSpec extract_atime(StatT const& st) { return st.st_atim; }300#endif301 302#if _LIBCPP_HAS_FILESYSTEM303 304# if !defined(_LIBCPP_WIN32API)305inline 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)315inline 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# endif323 324inline 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# else328 return posix_utimensat(p, TS, ec);329# endif330}331 332# endif // !_LIBCPP_WIN32API333 334inline 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_FILESYSTEM346 347} // namespace detail348 349_LIBCPP_END_NAMESPACE_FILESYSTEM350 351#endif // FILESYSTEM_TIME_UTILS_H352