lib/utimecmp.c

   1 /* utimecmp.c -- compare file timestamps
   2
   3    Copyright (C) 2004-2007, 2009-2024 Free Software Foundation, Inc.
   4
   5    This program is free software: you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation, either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  17
  18 /* Written by Paul Eggert.  */
  19
  20 #include <config.h>
  21
  22 #include "utimecmp.h"
  23
  24 #include <fcntl.h>
  25 #include <limits.h>
  26 #include <stdint.h>
  27 #include <stdlib.h>
  28 #include <sys/stat.h>
  29 #include <time.h>
  30 #include <unistd.h>
  31
  32 #include "dirname.h"
  33 #include "hash.h"
  34 #include "intprops.h"
  35 #include "stat-time.h"
  36
  37 #ifndef MAX
  38 # define MAX(a, b) ((a) > (b) ? (a) : (b))
  39 #endif
  40
  41 #define BILLION (1000 * 1000 * 1000)
  42
  43 /* Best possible resolution that utimens can set and stat can return,
  44    due to system-call limitations.  It must be a power of 10 that is
  45    no greater than 1 billion.  */
  46 #if HAVE_UTIMENSAT
  47 enum { SYSCALL_RESOLUTION = 1 };
  48 #elif defined _WIN32 && ! defined __CYGWIN__
  49 /* On native Windows, file times have 100 ns resolution. See
  50    <https://docs.microsoft.com/en-us/windows/desktop/api/minwinbase/ns-minwinbase-filetime>  */
  51 enum { SYSCALL_RESOLUTION = 100 };
  52 #elif ((HAVE_FUTIMESAT || HAVE_WORKING_UTIMES)                  \
  53        && (defined HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC             \
  54            || defined HAVE_STRUCT_STAT_ST_ATIMESPEC_TV_NSEC     \
  55            || defined HAVE_STRUCT_STAT_ST_ATIMENSEC             \
  56            || defined HAVE_STRUCT_STAT_ST_ATIM_ST__TIM_TV_NSEC))
  57 enum { SYSCALL_RESOLUTION = 1000 };
  58 #else
  59 enum { SYSCALL_RESOLUTION = BILLION };
  60 #endif
  61
  62 /* Describe a file system and its timestamp resolution in nanoseconds.  */
  63 struct fs_res
  64 {
  65   /* Device number of file system.  */
  66   dev_t dev;
  67
  68   /* An upper bound on the timestamp resolution of this file system,
  69      ignoring any resolution that cannot be set via utimens.  It is
  70      represented by an integer count of nanoseconds.  It must be
  71      either 2 billion, or a power of 10 that is no greater than a
  72      billion and is no less than SYSCALL_RESOLUTION.  */
  73   int resolution;
  74
  75   /* True if RESOLUTION is known to be exact, and is not merely an
  76      upper bound on the true resolution.  */
  77   bool exact;
  78 };
  79
  80 /* Hash some device info.  */
  81 static size_t
  82 dev_info_hash (void const *x, size_t table_size)
  83 {
  84   struct fs_res const *p = x;
  85
  86   /* Beware signed arithmetic gotchas.  */
  87   if (TYPE_SIGNED (dev_t) && SIZE_MAX < MAX (INT_MAX, TYPE_MAXIMUM (dev_t)))
  88     {
  89       uintmax_t dev = p->dev;
  90       return dev % table_size;
  91     }
  92
  93   return p->dev % table_size;
  94 }
  95
  96 /* Compare two dev_info structs.  */
  97 static bool
  98 dev_info_compare (void const *x, void const *y)
  99 {
 100   struct fs_res const *a = x;
 101   struct fs_res const *b = y;
 102   return a->dev == b->dev;
 103 }
 104
 105 /* Return -1, 0, 1 based on whether the destination file (relative
 106    to openat-like directory file descriptor DFD with name
 107    DST_NAME and status DST_STAT) is older than SRC_STAT, the same age
 108    as SRC_STAT, or newer than SRC_STAT, respectively.
 109
 110    DST_NAME may be NULL if OPTIONS is 0.
 111
 112    If OPTIONS & UTIMECMP_TRUNCATE_SOURCE, do the comparison after SRC is
 113    converted to the destination's timestamp resolution as filtered through
 114    utimens.  In this case, return -2 if the exact answer cannot be
 115    determined; this can happen only if the timestamps are very close and
 116    there is some trouble accessing the file system (e.g., the user does not
 117    have permission to futz with the destination's timestamps).  */
 118
 119 int
 120 utimecmp (char const *dst_name,
 121           struct stat const *dst_stat,
 122           struct stat const *src_stat,
 123           int options)
 124 {
 125   return utimecmpat (AT_FDCWD, dst_name, dst_stat, src_stat, options);
 126 }
 127
 128 int
 129 utimecmpat (int dfd, char const *dst_name,
 130             struct stat const *dst_stat,
 131             struct stat const *src_stat,
 132             int options)
 133 {
 134   /* Things to watch out for:
 135
 136      The code uses a static hash table internally and is not safe in the
 137      presence of signals, multiple threads, etc.  However, memory pressure
 138      that prevents use of the hash table is not fatal - we just fall back
 139      to redoing the computations on every call in that case.
 140
 141      int and long int might be 32 bits.  Many of the calculations store
 142      numbers up to 2 billion, and multiply by 10; they have to avoid
 143      multiplying 2 billion by 10, as this exceeds 32-bit capabilities.
 144
 145      time_t might be unsigned.  */
 146
 147   static_assert (TYPE_IS_INTEGER (time_t));
 148
 149   /* Destination and source timestamps.  */
 150   time_t dst_s = dst_stat->st_mtime;
 151   time_t src_s = src_stat->st_mtime;
 152   int dst_ns = get_stat_mtime_ns (dst_stat);
 153   int src_ns = get_stat_mtime_ns (src_stat);
 154
 155   if (options & UTIMECMP_TRUNCATE_SOURCE)
 156     {
 157 #if defined _AIX
 158       /* On AIX 7.2, on a jfs2 file system, the times may differ by up to
 159          0.01 seconds in either direction.  But it does not seem to come
 160          from clock ticks of 0.01 seconds each.  */
 161       long long difference =
 162         ((long long) dst_s - (long long) src_s) * BILLION
 163         + ((long long) dst_ns - (long long) src_ns);
 164       if (difference < 10000000 && difference > -10000000)
 165         return 0;
 166 #endif
 167
 168       /* Look up the timestamp resolution for the destination device.  */
 169
 170       /* Hash table for caching information learned about devices.  */
 171       static Hash_table *ht;
 172
 173       /* Information about the destination file system.  */
 174       static struct fs_res *new_dst_res;
 175       struct fs_res *dst_res = NULL;
 176       struct fs_res tmp_dst_res;
 177
 178       /* timestamp resolution in nanoseconds.  */
 179       int res;
 180
 181       /* Quick exit, if possible.  Since the worst resolution is 2
 182          seconds, anything that differs by more than that does not
 183          needs source truncation.  */
 184       if (dst_s == src_s && dst_ns == src_ns)
 185         return 0;
 186       if (dst_s <= src_s - 2)
 187         return -1;
 188       if (src_s <= dst_s - 2)
 189         return 1;
 190
 191       /* Try to do a hash lookup, but fall back to stack variables and
 192          recomputation on low memory situations.  */
 193       if (! ht)
 194         ht = hash_initialize (16, NULL, dev_info_hash, dev_info_compare, free);
 195       if (ht)
 196         {
 197           if (! new_dst_res)
 198             {
 199               new_dst_res = malloc (sizeof *new_dst_res);
 200               if (!new_dst_res)
 201                 goto low_memory;
 202               new_dst_res->resolution = 2 * BILLION;
 203               new_dst_res->exact = false;
 204             }
 205           new_dst_res->dev = dst_stat->st_dev;
 206           dst_res = hash_insert (ht, new_dst_res);
 207           if (! dst_res)
 208             goto low_memory;
 209
 210           if (dst_res == new_dst_res)
 211             {
 212               /* NEW_DST_RES is now in use in the hash table, so allocate a
 213                  new entry next time.  */
 214               new_dst_res = NULL;
 215             }
 216         }
 217       else
 218         {
 219         low_memory:
 220           if (ht)
 221             {
 222               tmp_dst_res.dev = dst_stat->st_dev;
 223               dst_res = hash_lookup (ht, &tmp_dst_res);
 224             }
 225           if (!dst_res)
 226             {
 227               dst_res = &tmp_dst_res;
 228               dst_res->resolution = 2 * BILLION;
 229               dst_res->exact = false;
 230             }
 231         }
 232
 233       res = dst_res->resolution;
 234
 235 #ifdef _PC_TIMESTAMP_RESOLUTION
 236       /* If the system will tell us the resolution, we're set!  */
 237       if (! dst_res->exact)
 238         {
 239           res = -1;
 240           if (dfd == AT_FDCWD)
 241             res = pathconf (dst_name, _PC_TIMESTAMP_RESOLUTION);
 242           else
 243             {
 244               char *dstdir = mdir_name (dst_name);
 245               if (dstdir)
 246                 {
 247                   int destdirfd = openat (dfd, dstdir,
 248                                           O_SEARCH | O_CLOEXEC | O_DIRECTORY);
 249                   if (0 <= destdirfd)
 250                     {
 251                       res = fpathconf (destdirfd, _PC_TIMESTAMP_RESOLUTION);
 252                       close (destdirfd);
 253                     }
 254                   free (dstdir);
 255                 }
 256             }
 257           if (0 < res)
 258             {
 259               dst_res->resolution = res;
 260               dst_res->exact = true;
 261             }
 262         }
 263 #endif
 264
 265       if (! dst_res->exact)
 266         {
 267           /* This file system's resolution is not known exactly.
 268              Deduce it, and store the result in the hash table.  */
 269
 270           time_t dst_a_s = dst_stat->st_atime;
 271           time_t dst_c_s = dst_stat->st_ctime;
 272           time_t dst_m_s = dst_s;
 273           int dst_a_ns = get_stat_atime_ns (dst_stat);
 274           int dst_c_ns = get_stat_ctime_ns (dst_stat);
 275           int dst_m_ns = dst_ns;
 276
 277           /* Set RES to an upper bound on the file system resolution
 278              (after truncation due to SYSCALL_RESOLUTION) by inspecting
 279              the atime, ctime and mtime of the existing destination.
 280              We don't know of any file system that stores atime or
 281              ctime with a higher precision than mtime, so it's valid to
 282              look at them too.  */
 283           {
 284             bool odd_second = (dst_a_s | dst_c_s | dst_m_s) & 1;
 285
 286             if (SYSCALL_RESOLUTION == BILLION)
 287               {
 288                 if (odd_second | dst_a_ns | dst_c_ns | dst_m_ns)
 289                   res = BILLION;
 290               }
 291             else
 292               {
 293                 int a = dst_a_ns;
 294                 int c = dst_c_ns;
 295                 int m = dst_m_ns;
 296
 297                 /* Write it this way to avoid mistaken GCC warning
 298                    about integer overflow in constant expression.  */
 299                 int SR10 = SYSCALL_RESOLUTION;  SR10 *= 10;
 300
 301                 if ((a % SR10 | c % SR10 | m % SR10) != 0)
 302                   res = SYSCALL_RESOLUTION;
 303                 else
 304                   for (res = SR10, a /= SR10, c /= SR10, m /= SR10;
 305                        (res < dst_res->resolution
 306                         && (a % 10 | c % 10 | m % 10) == 0);
 307                        res *= 10, a /= 10, c /= 10, m /= 10)
 308                     if (res == BILLION)
 309                       {
 310                         if (! odd_second)
 311                           res *= 2;
 312                         break;
 313                       }
 314               }
 315
 316             dst_res->resolution = res;
 317           }
 318
 319           if (SYSCALL_RESOLUTION < res)
 320             {
 321               struct stat dst_status;
 322
 323               /* Ignore source timestamp information that must necessarily
 324                  be lost when filtered through utimens.  */
 325               src_ns -= src_ns % SYSCALL_RESOLUTION;
 326
 327               /* If the timestamps disagree widely enough, there's no need
 328                  to interrogate the file system to deduce the exact
 329                  timestamp resolution; return the answer directly.  */
 330               {
 331                 time_t s = src_s & ~ (res == 2 * BILLION ? 1 : 0);
 332                 if (src_s < dst_s || (src_s == dst_s && src_ns <= dst_ns))
 333                   return 1;
 334                 if (dst_s < s
 335                     || (dst_s == s && dst_ns < src_ns - src_ns % res))
 336                   return -1;
 337               }
 338
 339               /* Determine the actual timestamp resolution for the
 340                  destination file system (after truncation due to
 341                  SYSCALL_RESOLUTION) by setting the access timestamp of the
 342                  destination to the existing access time, except with
 343                  trailing nonzero digits.  */
 344
 345               struct timespec timespec[2] = {
 346                 [0].tv_sec = dst_a_s,
 347                 [0].tv_nsec = dst_a_ns,
 348                 [1].tv_sec = dst_m_s | (res == 2 * BILLION),
 349                 [1].tv_nsec = dst_m_ns + res / 9
 350               };
 351
 352               if (utimensat (dfd, dst_name, timespec, AT_SYMLINK_NOFOLLOW))
 353                 return -2;
 354
 355               /* Read the modification time that was set.  */
 356               {
 357                 int stat_result
 358                   = fstatat (dfd, dst_name, &dst_status, AT_SYMLINK_NOFOLLOW);
 359
 360                 if (stat_result
 361                     | (dst_status.st_mtime ^ dst_m_s)
 362                     | (get_stat_mtime_ns (&dst_status) ^ dst_m_ns))
 363                   {
 364                     /* The modification time changed, or we can't tell whether
 365                        it changed.  Change it back as best we can.  */
 366                     timespec[1].tv_sec = dst_m_s;
 367                     timespec[1].tv_nsec = dst_m_ns;
 368                     utimensat (dfd, dst_name, timespec, AT_SYMLINK_NOFOLLOW);
 369                   }
 370
 371                 if (stat_result != 0)
 372                   return -2;
 373               }
 374
 375               /* Determine the exact resolution from the modification time
 376                  that was read back.  */
 377               {
 378                 int old_res = res;
 379                 int a = (BILLION * (dst_status.st_mtime & 1)
 380                          + get_stat_mtime_ns (&dst_status));
 381
 382                 res = SYSCALL_RESOLUTION;
 383
 384                 for (a /= res; a % 10 == 0; a /= 10)
 385                   {
 386                     if (res == BILLION)
 387                       {
 388                         res *= 2;
 389                         break;
 390                       }
 391                     res *= 10;
 392                     if (res == old_res)
 393                       break;
 394                   }
 395               }
 396             }
 397
 398           dst_res->resolution = res;
 399           dst_res->exact = true;
 400         }
 401
 402       /* Truncate the source's timestamp according to the resolution.  */
 403       src_s &= ~ (res == 2 * BILLION ? 1 : 0);
 404       src_ns -= src_ns % res;
 405     }
 406
 407   /* Compare the timestamps and return -1, 0, 1 accordingly.  */
 408   return (_GL_CMP (dst_s, src_s)
 409           + ((dst_s == src_s ? ~0 : 0) & _GL_CMP (dst_ns, src_ns)));
 410 }