1 /* utimecmp.c -- compare file time stamps
3 Copyright (C) 2004, 2005, 2006, 2007 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 3 of the License, or
8 (at your option) any later version.
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, see <http://www.gnu.org/licenses/>. */
18 /* Written by Paul Eggert. */
31 #include "stat-time.h"
37 # define MAX(a, b) ((a) > (b) ? (a) : (b))
40 enum { BILLION = 1000 * 1000 * 1000 };
42 /* Best possible resolution that utimens can set and stat can return,
43 due to system-call limitations. It must be a power of 10 that is
44 no greater than 1 billion. */
45 #if (HAVE_WORKING_UTIMES \
46 && (defined HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC \
47 || defined HAVE_STRUCT_STAT_ST_ATIMESPEC_TV_NSEC \
48 || defined HAVE_STRUCT_STAT_ST_ATIMENSEC \
49 || defined HAVE_STRUCT_STAT_ST_ATIM_ST__TIM_TV_NSEC \
50 || defined HAVE_STRUCT_STAT_ST_SPARE1))
51 enum { SYSCALL_RESOLUTION = 1000 };
53 enum { SYSCALL_RESOLUTION = BILLION };
56 /* Describe a file system and its time stamp resolution in nanoseconds. */
59 /* Device number of file system. */
62 /* An upper bound on the time stamp resolution of this file system,
63 ignoring any resolution that cannot be set via utimens. It is
64 represented by an integer count of nanoseconds. It must be
65 either 2 billion, or a power of 10 that is no greater than a
66 billion and is no less than SYSCALL_RESOLUTION. */
69 /* True if RESOLUTION is known to be exact, and is not merely an
70 upper bound on the true resolution. */
74 /* Hash some device info. */
76 dev_info_hash (void const *x, size_t table_size)
78 struct fs_res const *p = x;
80 /* Beware signed arithmetic gotchas. */
81 if (TYPE_SIGNED (dev_t) && SIZE_MAX < MAX (INT_MAX, TYPE_MAXIMUM (dev_t)))
83 uintmax_t dev = p->dev;
84 return dev % table_size;
87 return p->dev % table_size;
90 /* Compare two dev_info structs. */
92 dev_info_compare (void const *x, void const *y)
94 struct fs_res const *a = x;
95 struct fs_res const *b = y;
96 return a->dev == b->dev;
99 /* Return -1, 0, 1 based on whether the destination file (with name
100 DST_NAME and status DST_STAT) is older than SRC_STAT, the same age
101 as SRC_STAT, or newer than SRC_STAT, respectively.
103 If OPTIONS & UTIMECMP_TRUNCATE_SOURCE, do the comparison after SRC is
104 converted to the destination's timestamp resolution as filtered through
105 utimens. In this case, return -2 if the exact answer cannot be
106 determined; this can happen only if the time stamps are very close and
107 there is some trouble accessing the file system (e.g., the user does not
108 have permission to futz with the destination's time stamps). */
111 utimecmp (char const *dst_name,
112 struct stat const *dst_stat,
113 struct stat const *src_stat,
116 /* Things to watch out for:
118 The code uses a static hash table internally and is not safe in the
119 presence of signals, multiple threads, etc.
121 int and long int might be 32 bits. Many of the calculations store
122 numbers up to 2 billion, and multiply by 10; they have to avoid
123 multiplying 2 billion by 10, as this exceeds 32-bit capabilities.
125 time_t might be unsigned. */
127 verify (TYPE_IS_INTEGER (time_t));
128 verify (TYPE_TWOS_COMPLEMENT (int));
130 /* Destination and source time stamps. */
131 time_t dst_s = dst_stat->st_mtime;
132 time_t src_s = src_stat->st_mtime;
133 int dst_ns = get_stat_mtime_ns (dst_stat);
134 int src_ns = get_stat_mtime_ns (src_stat);
136 if (options & UTIMECMP_TRUNCATE_SOURCE)
138 /* Look up the time stamp resolution for the destination device. */
140 /* Hash table for devices. */
141 static Hash_table *ht;
143 /* Information about the destination file system. */
144 static struct fs_res *new_dst_res;
145 struct fs_res *dst_res;
147 /* Time stamp resolution in nanoseconds. */
151 ht = hash_initialize (16, NULL, dev_info_hash, dev_info_compare, free);
154 new_dst_res = xmalloc (sizeof *new_dst_res);
155 new_dst_res->resolution = 2 * BILLION;
156 new_dst_res->exact = false;
158 new_dst_res->dev = dst_stat->st_dev;
159 dst_res = hash_insert (ht, new_dst_res);
163 if (dst_res == new_dst_res)
165 /* NEW_DST_RES is now in use in the hash table, so allocate a
166 new entry next time. */
170 res = dst_res->resolution;
172 if (! dst_res->exact)
174 /* This file system's resolution is not known exactly.
175 Deduce it, and store the result in the hash table. */
177 time_t dst_a_s = dst_stat->st_atime;
178 time_t dst_c_s = dst_stat->st_ctime;
179 time_t dst_m_s = dst_s;
180 int dst_a_ns = get_stat_atime_ns (dst_stat);
181 int dst_c_ns = get_stat_ctime_ns (dst_stat);
182 int dst_m_ns = dst_ns;
184 /* Set RES to an upper bound on the file system resolution
185 (after truncation due to SYSCALL_RESOLUTION) by inspecting
186 the atime, ctime and mtime of the existing destination.
187 We don't know of any file system that stores atime or
188 ctime with a higher precision than mtime, so it's valid to
191 bool odd_second = (dst_a_s | dst_c_s | dst_m_s) & 1;
193 if (SYSCALL_RESOLUTION == BILLION)
195 if (odd_second | dst_a_ns | dst_c_ns | dst_m_ns)
204 /* Write it this way to avoid mistaken GCC warning
205 about integer overflow in constant expression. */
206 int SR10 = SYSCALL_RESOLUTION; SR10 *= 10;
208 if ((a % SR10 | c % SR10 | m % SR10) != 0)
209 res = SYSCALL_RESOLUTION;
211 for (res = SR10, a /= SR10, c /= SR10, m /= SR10;
212 (res < dst_res->resolution
213 && (a % 10 | c % 10 | m % 10) == 0);
214 res *= 10, a /= 10, c /= 10, m /= 10)
223 dst_res->resolution = res;
226 if (SYSCALL_RESOLUTION < res)
228 struct timespec timespec[2];
229 struct stat dst_status;
231 /* Ignore source time stamp information that must necessarily
232 be lost when filtered through utimens. */
233 src_ns -= src_ns % SYSCALL_RESOLUTION;
235 /* If the time stamps disagree widely enough, there's no need
236 to interrogate the file system to deduce the exact time
237 stamp resolution; return the answer directly. */
239 time_t s = src_s & ~ (res == 2 * BILLION);
240 if (src_s < dst_s || (src_s == dst_s && src_ns <= dst_ns))
243 || (dst_s == s && dst_ns < src_ns - src_ns % res))
247 /* Determine the actual time stamp resolution for the
248 destination file system (after truncation due to
249 SYSCALL_RESOLUTION) by setting the access time stamp of the
250 destination to the existing access time, except with
251 trailing nonzero digits. */
253 timespec[0].tv_sec = dst_a_s;
254 timespec[0].tv_nsec = dst_a_ns;
255 timespec[1].tv_sec = dst_m_s | (res == 2 * BILLION);
256 timespec[1].tv_nsec = dst_m_ns + res / 9;
258 /* Set the modification time. But don't try to set the
259 modification time of symbolic links; on many hosts this sets
260 the time of the pointed-to file. */
261 if (S_ISLNK (dst_stat->st_mode)
262 || utimens (dst_name, timespec) != 0)
265 /* Read the modification time that was set. It's safe to call
266 'stat' here instead of worrying about 'lstat'; either the
267 caller used 'stat', or the caller used 'lstat' and found
268 something other than a symbolic link. */
270 int stat_result = stat (dst_name, &dst_status);
273 | (dst_status.st_mtime ^ dst_m_s)
274 | (get_stat_mtime_ns (&dst_status) ^ dst_m_ns))
276 /* The modification time changed, or we can't tell whether
277 it changed. Change it back as best we can. */
278 timespec[1].tv_sec = dst_m_s;
279 timespec[1].tv_nsec = dst_m_ns;
280 utimens (dst_name, timespec);
283 if (stat_result != 0)
287 /* Determine the exact resolution from the modification time
288 that was read back. */
291 int a = (BILLION * (dst_status.st_mtime & 1)
292 + get_stat_mtime_ns (&dst_status));
294 res = SYSCALL_RESOLUTION;
296 for (a /= res; a % 10 != 0; a /= 10)
310 dst_res->resolution = res;
311 dst_res->exact = true;
314 /* Truncate the source's time stamp according to the resolution. */
315 src_s &= ~ (res == 2 * BILLION);
316 src_ns -= src_ns % res;
319 /* Compare the time stamps and return -1, 0, 1 accordingly. */
320 return (dst_s < src_s ? -1
322 : dst_ns < src_ns ? -1