1 /* utimecmp.c -- compare file time stamps
3 Copyright (C) 2004, 2005 Free Software Foundation, Inc.
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)
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.
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. */
19 /* Written by Paul Eggert. */
28 # include <inttypes.h>
39 #include "stat-time.h"
44 /* Verify a requirement at compile-time (unlike assert, which is runtime). */
45 #define verify(name, assertion) struct name { char a[(assertion) ? 1 : -1]; }
48 # define MAX(a, b) ((a) > (b) ? (a) : (b))
52 # define SIZE_MAX ((size_t) -1)
55 enum { BILLION = 1000 * 1000 * 1000 };
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 };
68 enum { SYSCALL_RESOLUTION = BILLION };
71 /* Describe a file system and its time stamp resolution in nanoseconds. */
74 /* Device number of file system. */
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. */
84 /* True if RESOLUTION is known to be exact, and is not merely an
85 upper bound on the true resolution. */
89 /* Hash some device info. */
91 dev_info_hash (void const *x, size_t table_size)
93 struct fs_res const *p = x;
95 /* Beware signed arithmetic gotchas. */
96 if (TYPE_SIGNED (dev_t) && SIZE_MAX < MAX (INT_MAX, TYPE_MAXIMUM (dev_t)))
98 uintmax_t dev = p->dev;
99 return dev % table_size;
102 return p->dev % table_size;
105 /* Compare two dev_info structs. */
107 dev_info_compare (void const *x, void const *y)
109 struct fs_res const *a = x;
110 struct fs_res const *b = y;
111 return a->dev == b->dev;
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.
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). */
126 utimecmp (char const *dst_name,
127 struct stat const *dst_stat,
128 struct stat const *src_stat,
131 /* Things to watch out for:
133 The code uses a static hash table internally and is not safe in the
134 presence of signals, multiple threads, etc.
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.
140 time_t might be unsigned. */
142 verify (time_t_is_integer, TYPE_IS_INTEGER (time_t));
143 verify (twos_complement_arithmetic, TYPE_TWOS_COMPLEMENT (int));
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);
151 if (options & UTIMECMP_TRUNCATE_SOURCE)
153 /* Look up the time stamp resolution for the destination device. */
155 /* Hash table for devices. */
156 static Hash_table *ht;
158 /* Information about the destination file system. */
159 static struct fs_res *new_dst_res;
160 struct fs_res *dst_res;
162 /* Time stamp resolution in nanoseconds. */
166 ht = hash_initialize (16, NULL, dev_info_hash, dev_info_compare, free);
169 new_dst_res = xmalloc (sizeof *new_dst_res);
170 new_dst_res->resolution = 2 * BILLION;
171 new_dst_res->exact = false;
173 new_dst_res->dev = dst_stat->st_dev;
174 dst_res = hash_insert (ht, new_dst_res);
178 if (dst_res == new_dst_res)
180 /* NEW_DST_RES is now in use in the hash table, so allocate a
181 new entry next time. */
185 res = dst_res->resolution;
187 if (! dst_res->exact)
189 /* This file system's resolution is not known exactly.
190 Deduce it, and store the result in the hash table. */
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;
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
206 bool odd_second = (dst_a_s | dst_c_s | dst_m_s) & 1;
208 if (SYSCALL_RESOLUTION == BILLION)
210 if (odd_second | dst_a_ns | dst_c_ns | dst_m_ns)
219 /* Write it this way to avoid mistaken GCC warning
220 about integer overflow in constant expression. */
221 int SR10 = SYSCALL_RESOLUTION; SR10 *= 10;
223 if ((a % SR10 | c % SR10 | m % SR10) != 0)
224 res = SYSCALL_RESOLUTION;
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)
238 dst_res->resolution = res;
241 if (SYSCALL_RESOLUTION < res)
243 struct timespec timespec[2];
244 struct stat dst_status;
246 /* Ignore source time stamp information that must necessarily
247 be lost when filtered through utimens. */
248 src_ns -= src_ns % SYSCALL_RESOLUTION;
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. */
254 time_t s = src_s & ~ (res == 2 * BILLION);
255 if (src_s < dst_s || (src_s == dst_s && src_ns <= dst_ns))
258 || (dst_s == s && dst_ns < src_ns - src_ns % res))
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. */
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;
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)
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. */
285 int stat_result = stat (dst_name, &dst_status);
288 | (dst_status.st_mtime ^ dst_m_s)
289 | (get_stat_mtime_ns (&dst_status) ^ dst_m_ns))
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);
298 if (stat_result != 0)
302 /* Determine the exact resolution from the modification time
303 that was read back. */
306 int a = (BILLION * (dst_status.st_mtime & 1)
307 + get_stat_mtime_ns (&dst_status));
309 res = SYSCALL_RESOLUTION;
311 for (a /= res; a % 10 != 0; a /= 10)
325 dst_res->resolution = res;
326 dst_res->exact = true;
329 /* Truncate the source's time stamp according to the resolution. */
330 src_s &= ~ (res == 2 * BILLION);
331 src_ns -= src_ns % res;
334 /* Compare the time stamps and return -1, 0, 1 accordingly. */
335 return (dst_s < src_s ? -1
337 : dst_ns < src_ns ? -1