lib/utimecmp.c

   1 /* utimecmp.c -- compare file time stamps
   2
   3    Copyright (C) 2004, 2005, 2006, 2007 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 2, or (at your option)
   8    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, write to the Free Software Foundation,
  17    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  18
  19 /* Written by Paul Eggert.  */
  20
  21 #include <config.h>
  22
  23 #include "utimecmp.h"
  24
  25 #include <limits.h>
  26 #include <stdbool.h>
  27 #include <stdint.h>
  28 #include <stdlib.h>
  29 #include <time.h>
  30 #include "hash.h"
  31 #include "intprops.h"
  32 #include "stat-time.h"
  33 #include "utimens.h"
  34 #include "verify.h"
  35 #include "xalloc.h"
  36
  37 #ifndef MAX
  38 # define MAX(a, b) ((a) > (b) ? (a) : (b))
  39 #endif
  40
  41 enum { 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_WORKING_UTIMES                                        \
  47      && (defined HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC               \
  48          || defined HAVE_STRUCT_STAT_ST_ATIMESPEC_TV_NSEC       \
  49          || defined HAVE_STRUCT_STAT_ST_ATIMENSEC               \
  50          || defined HAVE_STRUCT_STAT_ST_ATIM_ST__TIM_TV_NSEC    \
  51          || defined HAVE_STRUCT_STAT_ST_SPARE1))
  52 enum { SYSCALL_RESOLUTION = 1000 };
  53 #else
  54 enum { SYSCALL_RESOLUTION = BILLION };
  55 #endif
  56
  57 /* Describe a file system and its time stamp resolution in nanoseconds.  */
  58 struct fs_res
  59 {
  60   /* Device number of file system.  */
  61   dev_t dev;
  62
  63   /* An upper bound on the time stamp resolution of this file system,
  64      ignoring any resolution that cannot be set via utimens.  It is
  65      represented by an integer count of nanoseconds.  It must be
  66      either 2 billion, or a power of 10 that is no greater than a
  67      billion and is no less than SYSCALL_RESOLUTION.  */
  68   int resolution;
  69
  70   /* True if RESOLUTION is known to be exact, and is not merely an
  71      upper bound on the true resolution.  */
  72   bool exact;
  73 };
  74
  75 /* Hash some device info.  */
  76 static size_t
  77 dev_info_hash (void const *x, size_t table_size)
  78 {
  79   struct fs_res const *p = x;
  80
  81   /* Beware signed arithmetic gotchas.  */
  82   if (TYPE_SIGNED (dev_t) && SIZE_MAX < MAX (INT_MAX, TYPE_MAXIMUM (dev_t)))
  83     {
  84       uintmax_t dev = p->dev;
  85       return dev % table_size;
  86     }
  87
  88   return p->dev % table_size;
  89 }
  90
  91 /* Compare two dev_info structs.  */
  92 static bool
  93 dev_info_compare (void const *x, void const *y)
  94 {
  95   struct fs_res const *a = x;
  96   struct fs_res const *b = y;
  97   return a->dev == b->dev;
  98 }
  99
 100 /* Return -1, 0, 1 based on whether the destination file (with name
 101    DST_NAME and status DST_STAT) is older than SRC_STAT, the same age
 102    as SRC_STAT, or newer than SRC_STAT, respectively.
 103
 104    If OPTIONS & UTIMECMP_TRUNCATE_SOURCE, do the comparison after SRC is
 105    converted to the destination's timestamp resolution as filtered through
 106    utimens.  In this case, return -2 if the exact answer cannot be
 107    determined; this can happen only if the time stamps are very close and
 108    there is some trouble accessing the file system (e.g., the user does not
 109    have permission to futz with the destination's time stamps).  */
 110
 111 int
 112 utimecmp (char const *dst_name,
 113           struct stat const *dst_stat,
 114           struct stat const *src_stat,
 115           int options)
 116 {
 117   /* Things to watch out for:
 118
 119      The code uses a static hash table internally and is not safe in the
 120      presence of signals, multiple threads, etc.
 121
 122      int and long int might be 32 bits.  Many of the calculations store
 123      numbers up to 2 billion, and multiply by 10; they have to avoid
 124      multiplying 2 billion by 10, as this exceeds 32-bit capabilities.
 125
 126      time_t might be unsigned.  */
 127
 128   verify (TYPE_IS_INTEGER (time_t));
 129   verify (TYPE_TWOS_COMPLEMENT (int));
 130
 131   /* Destination and source time stamps.  */
 132   time_t dst_s = dst_stat->st_mtime;
 133   time_t src_s = src_stat->st_mtime;
 134   int dst_ns = get_stat_mtime_ns (dst_stat);
 135   int src_ns = get_stat_mtime_ns (src_stat);
 136
 137   if (options & UTIMECMP_TRUNCATE_SOURCE)
 138     {
 139       /* Look up the time stamp resolution for the destination device.  */
 140
 141       /* Hash table for devices.  */
 142       static Hash_table *ht;
 143
 144       /* Information about the destination file system.  */
 145       static struct fs_res *new_dst_res;
 146       struct fs_res *dst_res;
 147
 148       /* Time stamp resolution in nanoseconds.  */
 149       int res;
 150
 151       if (! ht)
 152         ht = hash_initialize (16, NULL, dev_info_hash, dev_info_compare, free);
 153       if (! new_dst_res)
 154         {
 155           new_dst_res = xmalloc (sizeof *new_dst_res);
 156           new_dst_res->resolution = 2 * BILLION;
 157           new_dst_res->exact = false;
 158         }
 159       new_dst_res->dev = dst_stat->st_dev;
 160       dst_res = hash_insert (ht, new_dst_res);
 161       if (! dst_res)
 162         xalloc_die ();
 163
 164       if (dst_res == new_dst_res)
 165         {
 166           /* NEW_DST_RES is now in use in the hash table, so allocate a
 167              new entry next time.  */
 168           new_dst_res = NULL;
 169         }
 170
 171       res = dst_res->resolution;
 172
 173       if (! dst_res->exact)
 174         {
 175           /* This file system's resolution is not known exactly.
 176              Deduce it, and store the result in the hash table.  */
 177
 178           time_t dst_a_s = dst_stat->st_atime;
 179           time_t dst_c_s = dst_stat->st_ctime;
 180           time_t dst_m_s = dst_s;
 181           int dst_a_ns = get_stat_atime_ns (dst_stat);
 182           int dst_c_ns = get_stat_ctime_ns (dst_stat);
 183           int dst_m_ns = dst_ns;
 184
 185           /* Set RES to an upper bound on the file system resolution
 186              (after truncation due to SYSCALL_RESOLUTION) by inspecting
 187              the atime, ctime and mtime of the existing destination.
 188              We don't know of any file system that stores atime or
 189              ctime with a higher precision than mtime, so it's valid to
 190              look at them too.  */
 191           {
 192             bool odd_second = (dst_a_s | dst_c_s | dst_m_s) & 1;
 193
 194             if (SYSCALL_RESOLUTION == BILLION)
 195               {
 196                 if (odd_second | dst_a_ns | dst_c_ns | dst_m_ns)
 197                   res = BILLION;
 198               }
 199             else
 200               {
 201                 int a = dst_a_ns;
 202                 int c = dst_c_ns;
 203                 int m = dst_m_ns;
 204
 205                 /* Write it this way to avoid mistaken GCC warning
 206                    about integer overflow in constant expression.  */
 207                 int SR10 = SYSCALL_RESOLUTION;  SR10 *= 10;
 208
 209                 if ((a % SR10 | c % SR10 | m % SR10) != 0)
 210                   res = SYSCALL_RESOLUTION;
 211                 else
 212                   for (res = SR10, a /= SR10, c /= SR10, m /= SR10;
 213                        (res < dst_res->resolution
 214                         && (a % 10 | c % 10 | m % 10) == 0);
 215                        res *= 10, a /= 10, c /= 10, m /= 10)
 216                     if (res == BILLION)
 217                       {
 218                         if (! odd_second)
 219                           res *= 2;
 220                         break;
 221                       }
 222               }
 223
 224             dst_res->resolution = res;
 225           }
 226
 227           if (SYSCALL_RESOLUTION < res)
 228             {
 229               struct timespec timespec[2];
 230               struct stat dst_status;
 231
 232               /* Ignore source time stamp information that must necessarily
 233                  be lost when filtered through utimens.  */
 234               src_ns -= src_ns % SYSCALL_RESOLUTION;
 235
 236               /* If the time stamps disagree widely enough, there's no need
 237                  to interrogate the file system to deduce the exact time
 238                  stamp resolution; return the answer directly.  */
 239               {
 240                 time_t s = src_s & ~ (res == 2 * BILLION);
 241                 if (src_s < dst_s || (src_s == dst_s && src_ns <= dst_ns))
 242                   return 1;
 243                 if (dst_s < s
 244                     || (dst_s == s && dst_ns < src_ns - src_ns % res))
 245                   return -1;
 246               }
 247
 248               /* Determine the actual time stamp resolution for the
 249                  destination file system (after truncation due to
 250                  SYSCALL_RESOLUTION) by setting the access time stamp of the
 251                  destination to the existing access time, except with
 252                  trailing nonzero digits.  */
 253
 254               timespec[0].tv_sec = dst_a_s;
 255               timespec[0].tv_nsec = dst_a_ns;
 256               timespec[1].tv_sec = dst_m_s | (res == 2 * BILLION);
 257               timespec[1].tv_nsec = dst_m_ns + res / 9;
 258
 259               /* Set the modification time.  But don't try to set the
 260                  modification time of symbolic links; on many hosts this sets
 261                  the time of the pointed-to file.  */
 262               if (S_ISLNK (dst_stat->st_mode)
 263                   || utimens (dst_name, timespec) != 0)
 264                 return -2;
 265
 266               /* Read the modification time that was set.  It's safe to call
 267                  'stat' here instead of worrying about 'lstat'; either the
 268                  caller used 'stat', or the caller used 'lstat' and found
 269                  something other than a symbolic link.  */
 270               {
 271                 int stat_result = stat (dst_name, &dst_status);
 272
 273                 if (stat_result
 274                     | (dst_status.st_mtime ^ dst_m_s)
 275                     | (get_stat_mtime_ns (&dst_status) ^ dst_m_ns))
 276                   {
 277                     /* The modification time changed, or we can't tell whether
 278                        it changed.  Change it back as best we can.  */
 279                     timespec[1].tv_sec = dst_m_s;
 280                     timespec[1].tv_nsec = dst_m_ns;
 281                     utimens (dst_name, timespec);
 282                   }
 283
 284                 if (stat_result != 0)
 285                   return -2;
 286               }
 287
 288               /* Determine the exact resolution from the modification time
 289                  that was read back.  */
 290               {
 291                 int old_res = res;
 292                 int a = (BILLION * (dst_status.st_mtime & 1)
 293                          + get_stat_mtime_ns (&dst_status));
 294
 295                 res = SYSCALL_RESOLUTION;
 296
 297                 for (a /= res; a % 10 != 0; a /= 10)
 298                   {
 299                     if (res == BILLION)
 300                       {
 301                         res *= 2;
 302                         break;
 303                       }
 304                     res *= 10;
 305                     if (res == old_res)
 306                       break;
 307                   }
 308               }
 309             }
 310
 311           dst_res->resolution = res;
 312           dst_res->exact = true;
 313         }
 314
 315       /* Truncate the source's time stamp according to the resolution.  */
 316       src_s &= ~ (res == 2 * BILLION);
 317       src_ns -= src_ns % res;
 318     }
 319
 320   /* Compare the time stamps and return -1, 0, 1 accordingly.  */
 321   return (dst_s < src_s ? -1
 322           : dst_s > src_s ? 1
 323           : dst_ns < src_ns ? -1
 324           : dst_ns > src_ns);
 325 }