lib/utimecmp.c

   1 /* utimecmp.c -- compare file timestamps
   2
   3    Copyright (C) 2004-2007, 2009-2017 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 <http://www.gnu.org/licenses/>.  */
  17
  18 /* Written by Paul Eggert.  */
  19
  20 #include <config.h>
  21
  22 #include "utimecmp.h"
  23
  24 #include <limits.h>
  25 #include <stdbool.h>
  26 #include <stdint.h>
  27 #include <stdlib.h>
  28 #include <time.h>
  29 #include <unistd.h>
  30
  31 #include "hash.h"
  32 #include "intprops.h"
  33 #include "stat-time.h"
  34 #include "utimens.h"
  35 #include "verify.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 __WIN32__) && ! defined __CYGWIN__
  49 /* On native Windows, file times have 100 ns resolution. See
  50    <https://msdn.microsoft.com/en-us/library/ms724284.aspx>  */
  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            || defined HAVE_STRUCT_STAT_ST_SPARE1))
  58 enum { SYSCALL_RESOLUTION = 1000 };
  59 #else
  60 enum { SYSCALL_RESOLUTION = BILLION };
  61 #endif
  62
  63 /* Describe a file system and its timestamp resolution in nanoseconds.  */
  64 struct fs_res
  65 {
  66   /* Device number of file system.  */
  67   dev_t dev;
  68
  69   /* An upper bound on the timestamp resolution of this file system,
  70      ignoring any resolution that cannot be set via utimens.  It is
  71      represented by an integer count of nanoseconds.  It must be
  72      either 2 billion, or a power of 10 that is no greater than a
  73      billion and is no less than SYSCALL_RESOLUTION.  */
  74   int resolution;
  75
  76   /* True if RESOLUTION is known to be exact, and is not merely an
  77      upper bound on the true resolution.  */
  78   bool exact;
  79 };
  80
  81 /* Hash some device info.  */
  82 static size_t
  83 dev_info_hash (void const *x, size_t table_size)
  84 {
  85   struct fs_res const *p = x;
  86
  87   /* Beware signed arithmetic gotchas.  */
  88   if (TYPE_SIGNED (dev_t) && SIZE_MAX < MAX (INT_MAX, TYPE_MAXIMUM (dev_t)))
  89     {
  90       uintmax_t dev = p->dev;
  91       return dev % table_size;
  92     }
  93
  94   return p->dev % table_size;
  95 }
  96
  97 /* Compare two dev_info structs.  */
  98 static bool
  99 dev_info_compare (void const *x, void const *y)
 100 {
 101   struct fs_res const *a = x;
 102   struct fs_res const *b = y;
 103   return a->dev == b->dev;
 104 }
 105
 106 /* Return -1, 0, 1 based on whether the destination file (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   /* Things to watch out for:
 126
 127      The code uses a static hash table internally and is not safe in the
 128      presence of signals, multiple threads, etc.  However, memory pressure
 129      that prevents use of the hash table is not fatal - we just fall back
 130      to redoing the computations on every call in that case.
 131
 132      int and long int might be 32 bits.  Many of the calculations store
 133      numbers up to 2 billion, and multiply by 10; they have to avoid
 134      multiplying 2 billion by 10, as this exceeds 32-bit capabilities.
 135
 136      time_t might be unsigned.  */
 137
 138   verify (TYPE_IS_INTEGER (time_t));
 139
 140   /* Destination and source timestamps.  */
 141   time_t dst_s = dst_stat->st_mtime;
 142   time_t src_s = src_stat->st_mtime;
 143   int dst_ns = get_stat_mtime_ns (dst_stat);
 144   int src_ns = get_stat_mtime_ns (src_stat);
 145
 146   if (options & UTIMECMP_TRUNCATE_SOURCE)
 147     {
 148       /* Look up the timestamp resolution for the destination device.  */
 149
 150       /* Hash table for caching information learned about devices.  */
 151       static Hash_table *ht;
 152
 153       /* Information about the destination file system.  */
 154       static struct fs_res *new_dst_res;
 155       struct fs_res *dst_res = NULL;
 156       struct fs_res tmp_dst_res;
 157
 158       /* timestamp resolution in nanoseconds.  */
 159       int res;
 160
 161       /* Quick exit, if possible.  Since the worst resolution is 2
 162          seconds, anything that differs by more than that does not
 163          needs source truncation.  */
 164       if (dst_s == src_s && dst_ns == src_ns)
 165         return 0;
 166       if (dst_s <= src_s - 2)
 167         return -1;
 168       if (src_s <= dst_s - 2)
 169         return 1;
 170
 171       /* Try to do a hash lookup, but fall back to stack variables and
 172          recomputation on low memory situations.  */
 173       if (! ht)
 174         ht = hash_initialize (16, NULL, dev_info_hash, dev_info_compare, free);
 175       if (ht)
 176         {
 177           if (! new_dst_res)
 178             {
 179               new_dst_res = malloc (sizeof *new_dst_res);
 180               if (!new_dst_res)
 181                 goto low_memory;
 182               new_dst_res->resolution = 2 * BILLION;
 183               new_dst_res->exact = false;
 184             }
 185           new_dst_res->dev = dst_stat->st_dev;
 186           dst_res = hash_insert (ht, new_dst_res);
 187           if (! dst_res)
 188             goto low_memory;
 189
 190           if (dst_res == new_dst_res)
 191             {
 192               /* NEW_DST_RES is now in use in the hash table, so allocate a
 193                  new entry next time.  */
 194               new_dst_res = NULL;
 195             }
 196         }
 197       else
 198         {
 199         low_memory:
 200           if (ht)
 201             {
 202               tmp_dst_res.dev = dst_stat->st_dev;
 203               dst_res = hash_lookup (ht, &tmp_dst_res);
 204             }
 205           if (!dst_res)
 206             {
 207               dst_res = &tmp_dst_res;
 208               dst_res->resolution = 2 * BILLION;
 209               dst_res->exact = false;
 210             }
 211         }
 212
 213       res = dst_res->resolution;
 214
 215 #ifdef _PC_TIMESTAMP_RESOLUTION
 216       /* If the system will tell us the resolution, we're set!  */
 217       if (! dst_res->exact)
 218         {
 219           res = pathconf (dst_name, _PC_TIMESTAMP_RESOLUTION);
 220           if (0 < res)
 221             {
 222               dst_res->resolution = res;
 223               dst_res->exact = true;
 224             }
 225         }
 226 #endif
 227
 228       if (! dst_res->exact)
 229         {
 230           /* This file system's resolution is not known exactly.
 231              Deduce it, and store the result in the hash table.  */
 232
 233           time_t dst_a_s = dst_stat->st_atime;
 234           time_t dst_c_s = dst_stat->st_ctime;
 235           time_t dst_m_s = dst_s;
 236           int dst_a_ns = get_stat_atime_ns (dst_stat);
 237           int dst_c_ns = get_stat_ctime_ns (dst_stat);
 238           int dst_m_ns = dst_ns;
 239
 240           /* Set RES to an upper bound on the file system resolution
 241              (after truncation due to SYSCALL_RESOLUTION) by inspecting
 242              the atime, ctime and mtime of the existing destination.
 243              We don't know of any file system that stores atime or
 244              ctime with a higher precision than mtime, so it's valid to
 245              look at them too.  */
 246           {
 247             bool odd_second = (dst_a_s | dst_c_s | dst_m_s) & 1;
 248
 249             if (SYSCALL_RESOLUTION == BILLION)
 250               {
 251                 if (odd_second | dst_a_ns | dst_c_ns | dst_m_ns)
 252                   res = BILLION;
 253               }
 254             else
 255               {
 256                 int a = dst_a_ns;
 257                 int c = dst_c_ns;
 258                 int m = dst_m_ns;
 259
 260                 /* Write it this way to avoid mistaken GCC warning
 261                    about integer overflow in constant expression.  */
 262                 int SR10 = SYSCALL_RESOLUTION;  SR10 *= 10;
 263
 264                 if ((a % SR10 | c % SR10 | m % SR10) != 0)
 265                   res = SYSCALL_RESOLUTION;
 266                 else
 267                   for (res = SR10, a /= SR10, c /= SR10, m /= SR10;
 268                        (res < dst_res->resolution
 269                         && (a % 10 | c % 10 | m % 10) == 0);
 270                        res *= 10, a /= 10, c /= 10, m /= 10)
 271                     if (res == BILLION)
 272                       {
 273                         if (! odd_second)
 274                           res *= 2;
 275                         break;
 276                       }
 277               }
 278
 279             dst_res->resolution = res;
 280           }
 281
 282           if (SYSCALL_RESOLUTION < res)
 283             {
 284               struct timespec timespec[2];
 285               struct stat dst_status;
 286
 287               /* Ignore source timestamp information that must necessarily
 288                  be lost when filtered through utimens.  */
 289               src_ns -= src_ns % SYSCALL_RESOLUTION;
 290
 291               /* If the timestamps disagree widely enough, there's no need
 292                  to interrogate the file system to deduce the exact
 293                  timestamp resolution; return the answer directly.  */
 294               {
 295                 time_t s = src_s & ~ (res == 2 * BILLION ? 1 : 0);
 296                 if (src_s < dst_s || (src_s == dst_s && src_ns <= dst_ns))
 297                   return 1;
 298                 if (dst_s < s
 299                     || (dst_s == s && dst_ns < src_ns - src_ns % res))
 300                   return -1;
 301               }
 302
 303               /* Determine the actual timestamp resolution for the
 304                  destination file system (after truncation due to
 305                  SYSCALL_RESOLUTION) by setting the access timestamp of the
 306                  destination to the existing access time, except with
 307                  trailing nonzero digits.  */
 308
 309               timespec[0].tv_sec = dst_a_s;
 310               timespec[0].tv_nsec = dst_a_ns;
 311               timespec[1].tv_sec = dst_m_s | (res == 2 * BILLION);
 312               timespec[1].tv_nsec = dst_m_ns + res / 9;
 313
 314               /* Set the modification time.  But don't try to set the
 315                  modification time of symbolic links; on many hosts this sets
 316                  the time of the pointed-to file.  */
 317               if ((S_ISLNK (dst_stat->st_mode)
 318                    ? lutimens (dst_name, timespec)
 319                    : utimens (dst_name, timespec)) != 0)
 320                 return -2;
 321
 322               /* Read the modification time that was set.  */
 323               {
 324                 int stat_result = (S_ISLNK (dst_stat->st_mode)
 325                                    ? lstat (dst_name, &dst_status)
 326                                    : stat (dst_name, &dst_status));
 327
 328                 if (stat_result
 329                     | (dst_status.st_mtime ^ dst_m_s)
 330                     | (get_stat_mtime_ns (&dst_status) ^ dst_m_ns))
 331                   {
 332                     /* The modification time changed, or we can't tell whether
 333                        it changed.  Change it back as best we can.  */
 334                     timespec[1].tv_sec = dst_m_s;
 335                     timespec[1].tv_nsec = dst_m_ns;
 336                     if (S_ISLNK (dst_stat->st_mode))
 337                       lutimens (dst_name, timespec);
 338                     else
 339                       utimens (dst_name, timespec);
 340                   }
 341
 342                 if (stat_result != 0)
 343                   return -2;
 344               }
 345
 346               /* Determine the exact resolution from the modification time
 347                  that was read back.  */
 348               {
 349                 int old_res = res;
 350                 int a = (BILLION * (dst_status.st_mtime & 1)
 351                          + get_stat_mtime_ns (&dst_status));
 352
 353                 res = SYSCALL_RESOLUTION;
 354
 355                 for (a /= res; a % 10 == 0; a /= 10)
 356                   {
 357                     if (res == BILLION)
 358                       {
 359                         res *= 2;
 360                         break;
 361                       }
 362                     res *= 10;
 363                     if (res == old_res)
 364                       break;
 365                   }
 366               }
 367             }
 368
 369           dst_res->resolution = res;
 370           dst_res->exact = true;
 371         }
 372
 373       /* Truncate the source's timestamp according to the resolution.  */
 374       src_s &= ~ (res == 2 * BILLION ? 1 : 0);
 375       src_ns -= src_ns % res;
 376     }
 377
 378   /* Compare the timestamps and return -1, 0, 1 accordingly.  */
 379   return (dst_s < src_s ? -1
 380           : dst_s > src_s ? 1
 381           : dst_ns < src_ns ? -1
 382           : dst_ns > src_ns);
 383 }