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