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>
43 /* Verify a requirement at compile-time (unlike assert, which is runtime). */
44 #define verify(name, assertion) struct name { char a[(assertion) ? 1 : -1]; }
47 # define MAX(a, b) ((a) > (b) ? (a) : (b))
51 # define SIZE_MAX ((size_t) -1)
54 enum { BILLION = 1000 * 1000 * 1000 };
56 /* Best possible resolution that utimens can set and stat can return,
57 due to system-call limitations. It must be a power of 10 that is
58 no greater than 1 billion. */
59 #if HAVE_WORKING_UTIMES && defined ST_MTIM_NSEC
60 enum { SYSCALL_RESOLUTION = 1000 };
62 enum { SYSCALL_RESOLUTION = BILLION };
65 /* Describe a file system and its time stamp resolution in nanoseconds. */
68 /* Device number of file system. */
71 /* An upper bound on the time stamp resolution of this file system,
72 ignoring any resolution that cannot be set via utimens. It is
73 represented by an integer count of nanoseconds. It must be
74 either 2 billion, or a power of 10 that is no greater than a
75 billion and is no less than SYSCALL_RESOLUTION. */
78 /* True if RESOLUTION is known to be exact, and is not merely an
79 upper bound on the true resolution. */
83 /* Hash some device info. */
85 dev_info_hash (void const *x, size_t table_size)
87 struct fs_res const *p = x;
89 /* Beware signed arithmetic gotchas. */
90 if (TYPE_SIGNED (dev_t) && SIZE_MAX < MAX (INT_MAX, TYPE_MAXIMUM (dev_t)))
92 uintmax_t dev = p->dev;
93 return dev % table_size;
96 return p->dev % table_size;
99 /* Compare two dev_info structs. */
101 dev_info_compare (void const *x, void const *y)
103 struct fs_res const *a = x;
104 struct fs_res const *b = y;
105 return a->dev == b->dev;
108 /* Return -1, 0, 1 based on whether the destination file (with name
109 DST_NAME and status DST_STAT) is older than SRC_STAT, the same age
110 as SRC_STAT, or newer than SRC_STAT, respectively.
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 time stamps 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 time stamps). */
120 utimecmp (char const *dst_name,
121 struct stat const *dst_stat,
122 struct stat const *src_stat,
125 /* Things to watch out for:
127 The code uses a static hash table internally and is not safe in the
128 presence of signals, multiple threads, etc.
130 int and long int might be 32 bits. Many of the calculations store
131 numbers up to 2 billion, and multiply by 10; they have to avoid
132 multiplying 2 billion by 10, as this exceeds 32-bit capabilities.
134 time_t might be unsigned. */
136 verify (time_t_is_integer, TYPE_IS_INTEGER (time_t));
137 verify (twos_complement_arithmetic, TYPE_TWOS_COMPLEMENT (int));
139 /* Destination and source time stamps. */
140 time_t dst_s = dst_stat->st_mtime;
141 time_t src_s = src_stat->st_mtime;
142 int dst_ns = TIMESPEC_NS (dst_stat->st_mtim);
143 int src_ns = TIMESPEC_NS (src_stat->st_mtim);
145 if (options & UTIMECMP_TRUNCATE_SOURCE)
147 /* Look up the time stamp resolution for the destination device. */
149 /* Hash table for devices. */
150 static Hash_table *ht;
152 /* Information about the destination file system. */
153 static struct fs_res *new_dst_res;
154 struct fs_res *dst_res;
156 /* Time stamp resolution in nanoseconds. */
160 ht = hash_initialize (16, NULL, dev_info_hash, dev_info_compare, free);
163 new_dst_res = xmalloc (sizeof *new_dst_res);
164 new_dst_res->resolution = 2 * BILLION;
165 new_dst_res->exact = false;
167 new_dst_res->dev = dst_stat->st_dev;
168 dst_res = hash_insert (ht, new_dst_res);
172 if (dst_res == new_dst_res)
174 /* NEW_DST_RES is now in use in the hash table, so allocate a
175 new entry next time. */
179 res = dst_res->resolution;
181 if (! dst_res->exact)
183 /* This file system's resolution is not known exactly.
184 Deduce it, and store the result in the hash table. */
186 time_t dst_a_s = dst_stat->st_atime;
187 time_t dst_c_s = dst_stat->st_ctime;
188 time_t dst_m_s = dst_s;
189 int dst_a_ns = TIMESPEC_NS (dst_stat->st_atim);
190 int dst_c_ns = TIMESPEC_NS (dst_stat->st_ctim);
191 int dst_m_ns = dst_ns;
193 /* Set RES to an upper bound on the file system resolution
194 (after truncation due to SYSCALL_RESOLUTION) by inspecting
195 the atime, ctime and mtime of the existing destination.
196 We don't know of any file system that stores atime or
197 ctime with a higher precision than mtime, so it's valid to
200 bool odd_second = (dst_a_s | dst_c_s | dst_m_s) & 1;
202 if (SYSCALL_RESOLUTION == BILLION)
204 if (odd_second | dst_a_ns | dst_c_ns | dst_m_ns)
213 /* Write it this way to avoid mistaken GCC warning
214 about integer overflow in constant expression. */
215 int SR10 = SYSCALL_RESOLUTION; SR10 *= 10;
217 if ((a % SR10 | c % SR10 | m % SR10) != 0)
218 res = SYSCALL_RESOLUTION;
220 for (res = SR10, a /= SR10, c /= SR10, m /= SR10;
221 (res < dst_res->resolution
222 && (a % 10 | c % 10 | m % 10) == 0);
223 res *= 10, a /= 10, c /= 10, m /= 10)
232 dst_res->resolution = res;
235 if (SYSCALL_RESOLUTION < res)
237 struct timespec timespec[2];
238 struct stat dst_status;
240 /* Ignore source time stamp information that must necessarily
241 be lost when filtered through utimens. */
242 src_ns -= src_ns % SYSCALL_RESOLUTION;
244 /* If the time stamps disagree widely enough, there's no need
245 to interrogate the file system to deduce the exact time
246 stamp resolution; return the answer directly. */
248 time_t s = src_s & ~ (res == 2 * BILLION);
249 if (src_s < dst_s || (src_s == dst_s && src_ns <= dst_ns))
252 || (dst_s == s && dst_ns < src_ns - src_ns % res))
256 /* Determine the actual time stamp resolution for the
257 destination file system (after truncation due to
258 SYSCALL_RESOLUTION) by setting the access time stamp of the
259 destination to the existing access time, except with
260 trailing nonzero digits. */
262 timespec[0].tv_sec = dst_a_s;
263 timespec[0].tv_nsec = dst_a_ns;
264 timespec[1].tv_sec = dst_m_s | (res == 2 * BILLION);
265 timespec[1].tv_nsec = dst_m_ns + res / 9;
267 /* Set the modification time. But don't try to set the
268 modification time of symbolic links; on many hosts this sets
269 the time of the pointed-to file. */
270 if (S_ISLNK (dst_stat->st_mode)
271 || utimens (dst_name, timespec) != 0)
274 /* Read the modification time that was set. It's safe to call
275 'stat' here instead of worrying about 'lstat'; either the
276 caller used 'stat', or the caller used 'lstat' and found
277 something other than a symbolic link. */
279 int stat_result = stat (dst_name, &dst_status);
282 | (dst_status.st_mtime ^ dst_m_s)
283 | (TIMESPEC_NS (dst_status.st_mtim) ^ dst_m_ns))
285 /* The modification time changed, or we can't tell whether
286 it changed. Change it back as best we can. */
287 timespec[1].tv_sec = dst_m_s;
288 timespec[1].tv_nsec = dst_m_ns;
289 utimens (dst_name, timespec);
292 if (stat_result != 0)
296 /* Determine the exact resolution from the modification time
297 that was read back. */
300 int a = (BILLION * (dst_status.st_mtime & 1)
301 + TIMESPEC_NS (dst_status.st_mtim));
303 res = SYSCALL_RESOLUTION;
305 for (a /= res; a % 10 != 0; a /= 10)
319 dst_res->resolution = res;
320 dst_res->exact = true;
323 /* Truncate the source's time stamp according to the resolution. */
324 src_s &= ~ (res == 2 * BILLION);
325 src_ns -= src_ns % res;
328 /* Compare the time stamps and return -1, 0, 1 accordingly. */
329 return (dst_s < src_s ? -1
331 : dst_ns < src_ns ? -1