lib/utimecmp.c

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