Commit | Line | Data |
---|---|---|
c8fff863 PE |
1 | /* Set file access and modification times. |
2 | ||
3 | Copyright (C) 2003-2012 Free Software Foundation, Inc. | |
4 | ||
5 | This program is free software: you can redistribute it and/or modify it | |
6 | under the terms of the GNU General Public License as published by the | |
7 | Free Software Foundation; either version 3 of the License, or any | |
8 | 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 | /* derived from a function in touch.c */ | |
21 | ||
22 | #include <config.h> | |
23 | ||
24 | #include "utimens.h" | |
25 | ||
26 | #include <assert.h> | |
27 | #include <errno.h> | |
28 | #include <fcntl.h> | |
29 | #include <stdbool.h> | |
30 | #include <sys/stat.h> | |
31 | #include <sys/time.h> | |
32 | #include <unistd.h> | |
33 | ||
34 | #include "stat-time.h" | |
35 | #include "timespec.h" | |
36 | ||
37 | #if HAVE_UTIME_H | |
38 | # include <utime.h> | |
39 | #endif | |
40 | ||
41 | /* Some systems (even some that do have <utime.h>) don't declare this | |
42 | structure anywhere. */ | |
43 | #ifndef HAVE_STRUCT_UTIMBUF | |
44 | struct utimbuf | |
45 | { | |
46 | long actime; | |
47 | long modtime; | |
48 | }; | |
49 | #endif | |
50 | ||
51 | /* Avoid recursion with rpl_futimens or rpl_utimensat. */ | |
52 | #undef futimens | |
53 | #undef utimensat | |
54 | ||
55 | /* Solaris 9 mistakenly succeeds when given a non-directory with a | |
56 | trailing slash. Force the use of rpl_stat for a fix. */ | |
57 | #ifndef REPLACE_FUNC_STAT_FILE | |
58 | # define REPLACE_FUNC_STAT_FILE 0 | |
59 | #endif | |
60 | ||
61 | #if HAVE_UTIMENSAT || HAVE_FUTIMENS | |
62 | /* Cache variables for whether the utimensat syscall works; used to | |
63 | avoid calling the syscall if we know it will just fail with ENOSYS, | |
64 | and to avoid unnecessary work in massaging timestamps if the | |
65 | syscall will work. Multiple variables are needed, to distinguish | |
66 | between the following scenarios on Linux: | |
67 | utimensat doesn't exist, or is in glibc but kernel 2.6.18 fails with ENOSYS | |
68 | kernel 2.6.22 and earlier rejects AT_SYMLINK_NOFOLLOW | |
69 | kernel 2.6.25 and earlier reject UTIME_NOW/UTIME_OMIT with non-zero tv_sec | |
70 | kernel 2.6.32 used with xfs or ntfs-3g fail to honor UTIME_OMIT | |
71 | utimensat completely works | |
72 | For each cache variable: 0 = unknown, 1 = yes, -1 = no. */ | |
73 | static int utimensat_works_really; | |
74 | static int lutimensat_works_really; | |
75 | #endif /* HAVE_UTIMENSAT || HAVE_FUTIMENS */ | |
76 | ||
77 | /* Validate the requested timestamps. Return 0 if the resulting | |
78 | timespec can be used for utimensat (after possibly modifying it to | |
79 | work around bugs in utimensat). Return a positive value if the | |
80 | timespec needs further adjustment based on stat results: 1 if any | |
81 | adjustment is needed for utimes, and 2 if any adjustment is needed | |
82 | for Linux utimensat. Return -1, with errno set to EINVAL, if | |
83 | timespec is out of range. */ | |
84 | static int | |
85 | validate_timespec (struct timespec timespec[2]) | |
86 | { | |
87 | int result = 0; | |
88 | int utime_omit_count = 0; | |
89 | assert (timespec); | |
90 | if ((timespec[0].tv_nsec != UTIME_NOW | |
91 | && timespec[0].tv_nsec != UTIME_OMIT | |
92 | && (timespec[0].tv_nsec < 0 || 1000000000 <= timespec[0].tv_nsec)) | |
93 | || (timespec[1].tv_nsec != UTIME_NOW | |
94 | && timespec[1].tv_nsec != UTIME_OMIT | |
95 | && (timespec[1].tv_nsec < 0 || 1000000000 <= timespec[1].tv_nsec))) | |
96 | { | |
97 | errno = EINVAL; | |
98 | return -1; | |
99 | } | |
100 | /* Work around Linux kernel 2.6.25 bug, where utimensat fails with | |
101 | EINVAL if tv_sec is not 0 when using the flag values of tv_nsec. | |
102 | Flag a Linux kernel 2.6.32 bug, where an mtime of UTIME_OMIT | |
103 | fails to bump ctime. */ | |
104 | if (timespec[0].tv_nsec == UTIME_NOW | |
105 | || timespec[0].tv_nsec == UTIME_OMIT) | |
106 | { | |
107 | timespec[0].tv_sec = 0; | |
108 | result = 1; | |
109 | if (timespec[0].tv_nsec == UTIME_OMIT) | |
110 | utime_omit_count++; | |
111 | } | |
112 | if (timespec[1].tv_nsec == UTIME_NOW | |
113 | || timespec[1].tv_nsec == UTIME_OMIT) | |
114 | { | |
115 | timespec[1].tv_sec = 0; | |
116 | result = 1; | |
117 | if (timespec[1].tv_nsec == UTIME_OMIT) | |
118 | utime_omit_count++; | |
119 | } | |
120 | return result + (utime_omit_count == 1); | |
121 | } | |
122 | ||
123 | /* Normalize any UTIME_NOW or UTIME_OMIT values in *TS, using stat | |
124 | buffer STATBUF to obtain the current timestamps of the file. If | |
125 | both times are UTIME_NOW, set *TS to NULL (as this can avoid some | |
126 | permissions issues). If both times are UTIME_OMIT, return true | |
127 | (nothing further beyond the prior collection of STATBUF is | |
128 | necessary); otherwise return false. */ | |
129 | static bool | |
130 | update_timespec (struct stat const *statbuf, struct timespec *ts[2]) | |
131 | { | |
132 | struct timespec *timespec = *ts; | |
133 | if (timespec[0].tv_nsec == UTIME_OMIT | |
134 | && timespec[1].tv_nsec == UTIME_OMIT) | |
135 | return true; | |
136 | if (timespec[0].tv_nsec == UTIME_NOW | |
137 | && timespec[1].tv_nsec == UTIME_NOW) | |
138 | { | |
139 | *ts = NULL; | |
140 | return false; | |
141 | } | |
142 | ||
143 | if (timespec[0].tv_nsec == UTIME_OMIT) | |
144 | timespec[0] = get_stat_atime (statbuf); | |
145 | else if (timespec[0].tv_nsec == UTIME_NOW) | |
146 | gettime (×pec[0]); | |
147 | ||
148 | if (timespec[1].tv_nsec == UTIME_OMIT) | |
149 | timespec[1] = get_stat_mtime (statbuf); | |
150 | else if (timespec[1].tv_nsec == UTIME_NOW) | |
151 | gettime (×pec[1]); | |
152 | ||
153 | return false; | |
154 | } | |
155 | ||
156 | /* Set the access and modification time stamps of FD (a.k.a. FILE) to be | |
157 | TIMESPEC[0] and TIMESPEC[1], respectively. | |
158 | FD must be either negative -- in which case it is ignored -- | |
159 | or a file descriptor that is open on FILE. | |
160 | If FD is nonnegative, then FILE can be NULL, which means | |
161 | use just futimes (or equivalent) instead of utimes (or equivalent), | |
162 | and fail if on an old system without futimes (or equivalent). | |
163 | If TIMESPEC is null, set the time stamps to the current time. | |
164 | Return 0 on success, -1 (setting errno) on failure. */ | |
165 | ||
166 | int | |
167 | fdutimens (int fd, char const *file, struct timespec const timespec[2]) | |
168 | { | |
169 | struct timespec adjusted_timespec[2]; | |
170 | struct timespec *ts = timespec ? adjusted_timespec : NULL; | |
171 | int adjustment_needed = 0; | |
172 | struct stat st; | |
173 | ||
174 | if (ts) | |
175 | { | |
176 | adjusted_timespec[0] = timespec[0]; | |
177 | adjusted_timespec[1] = timespec[1]; | |
178 | adjustment_needed = validate_timespec (ts); | |
179 | } | |
180 | if (adjustment_needed < 0) | |
181 | return -1; | |
182 | ||
183 | /* Require that at least one of FD or FILE are potentially valid, to avoid | |
184 | a Linux bug where futimens (AT_FDCWD, NULL) changes "." rather | |
185 | than failing. */ | |
186 | if (fd < 0 && !file) | |
187 | { | |
188 | errno = EBADF; | |
189 | return -1; | |
190 | } | |
191 | ||
192 | /* Some Linux-based NFS clients are buggy, and mishandle time stamps | |
193 | of files in NFS file systems in some cases. We have no | |
194 | configure-time test for this, but please see | |
195 | <http://bugs.gentoo.org/show_bug.cgi?id=132673> for references to | |
196 | some of the problems with Linux 2.6.16. If this affects you, | |
197 | compile with -DHAVE_BUGGY_NFS_TIME_STAMPS; this is reported to | |
198 | help in some cases, albeit at a cost in performance. But you | |
199 | really should upgrade your kernel to a fixed version, since the | |
200 | problem affects many applications. */ | |
201 | ||
202 | #if HAVE_BUGGY_NFS_TIME_STAMPS | |
203 | if (fd < 0) | |
204 | sync (); | |
205 | else | |
206 | fsync (fd); | |
207 | #endif | |
208 | ||
209 | /* POSIX 2008 added two interfaces to set file timestamps with | |
210 | nanosecond resolution; newer Linux implements both functions via | |
211 | a single syscall. We provide a fallback for ENOSYS (for example, | |
212 | compiling against Linux 2.6.25 kernel headers and glibc 2.7, but | |
213 | running on Linux 2.6.18 kernel). */ | |
214 | #if HAVE_UTIMENSAT || HAVE_FUTIMENS | |
215 | if (0 <= utimensat_works_really) | |
216 | { | |
217 | int result; | |
218 | # if __linux__ | |
219 | /* As recently as Linux kernel 2.6.32 (Dec 2009), several file | |
220 | systems (xfs, ntfs-3g) have bugs with a single UTIME_OMIT, | |
221 | but work if both times are either explicitly specified or | |
222 | UTIME_NOW. Work around it with a preparatory [f]stat prior | |
223 | to calling futimens/utimensat; fortunately, there is not much | |
224 | timing impact due to the extra syscall even on file systems | |
225 | where UTIME_OMIT would have worked. FIXME: Simplify this in | |
226 | 2012, when file system bugs are no longer common. */ | |
227 | if (adjustment_needed == 2) | |
228 | { | |
229 | if (fd < 0 ? stat (file, &st) : fstat (fd, &st)) | |
230 | return -1; | |
231 | if (ts[0].tv_nsec == UTIME_OMIT) | |
232 | ts[0] = get_stat_atime (&st); | |
233 | else if (ts[1].tv_nsec == UTIME_OMIT) | |
234 | ts[1] = get_stat_mtime (&st); | |
235 | /* Note that st is good, in case utimensat gives ENOSYS. */ | |
236 | adjustment_needed++; | |
237 | } | |
238 | # endif /* __linux__ */ | |
239 | # if HAVE_UTIMENSAT | |
240 | if (fd < 0) | |
241 | { | |
242 | result = utimensat (AT_FDCWD, file, ts, 0); | |
243 | # ifdef __linux__ | |
244 | /* Work around a kernel bug: | |
245 | http://bugzilla.redhat.com/442352 | |
246 | http://bugzilla.redhat.com/449910 | |
247 | It appears that utimensat can mistakenly return 280 rather | |
248 | than -1 upon ENOSYS failure. | |
249 | FIXME: remove in 2010 or whenever the offending kernels | |
250 | are no longer in common use. */ | |
251 | if (0 < result) | |
252 | errno = ENOSYS; | |
253 | # endif /* __linux__ */ | |
254 | if (result == 0 || errno != ENOSYS) | |
255 | { | |
256 | utimensat_works_really = 1; | |
257 | return result; | |
258 | } | |
259 | } | |
260 | # endif /* HAVE_UTIMENSAT */ | |
261 | # if HAVE_FUTIMENS | |
262 | if (0 <= fd) | |
263 | { | |
264 | result = futimens (fd, ts); | |
265 | # ifdef __linux__ | |
266 | /* Work around the same bug as above. */ | |
267 | if (0 < result) | |
268 | errno = ENOSYS; | |
269 | # endif /* __linux__ */ | |
270 | if (result == 0 || errno != ENOSYS) | |
271 | { | |
272 | utimensat_works_really = 1; | |
273 | return result; | |
274 | } | |
275 | } | |
276 | # endif /* HAVE_FUTIMENS */ | |
277 | } | |
278 | utimensat_works_really = -1; | |
279 | lutimensat_works_really = -1; | |
280 | #endif /* HAVE_UTIMENSAT || HAVE_FUTIMENS */ | |
281 | ||
282 | /* The platform lacks an interface to set file timestamps with | |
283 | nanosecond resolution, so do the best we can, discarding any | |
284 | fractional part of the timestamp. */ | |
285 | ||
286 | if (adjustment_needed || (REPLACE_FUNC_STAT_FILE && fd < 0)) | |
287 | { | |
288 | if (adjustment_needed != 3 | |
289 | && (fd < 0 ? stat (file, &st) : fstat (fd, &st))) | |
290 | return -1; | |
291 | if (ts && update_timespec (&st, &ts)) | |
292 | return 0; | |
293 | } | |
294 | ||
295 | { | |
296 | #if HAVE_FUTIMESAT || HAVE_WORKING_UTIMES | |
297 | struct timeval timeval[2]; | |
298 | struct timeval *t; | |
299 | if (ts) | |
300 | { | |
301 | timeval[0].tv_sec = ts[0].tv_sec; | |
302 | timeval[0].tv_usec = ts[0].tv_nsec / 1000; | |
303 | timeval[1].tv_sec = ts[1].tv_sec; | |
304 | timeval[1].tv_usec = ts[1].tv_nsec / 1000; | |
305 | t = timeval; | |
306 | } | |
307 | else | |
308 | t = NULL; | |
309 | ||
310 | if (fd < 0) | |
311 | { | |
312 | # if HAVE_FUTIMESAT | |
313 | return futimesat (AT_FDCWD, file, t); | |
314 | # endif | |
315 | } | |
316 | else | |
317 | { | |
318 | /* If futimesat or futimes fails here, don't try to speed things | |
319 | up by returning right away. glibc can incorrectly fail with | |
320 | errno == ENOENT if /proc isn't mounted. Also, Mandrake 10.0 | |
321 | in high security mode doesn't allow ordinary users to read | |
322 | /proc/self, so glibc incorrectly fails with errno == EACCES. | |
323 | If errno == EIO, EPERM, or EROFS, it's probably safe to fail | |
324 | right away, but these cases are rare enough that they're not | |
325 | worth optimizing, and who knows what other messed-up systems | |
326 | are out there? So play it safe and fall back on the code | |
327 | below. */ | |
328 | ||
329 | # if (HAVE_FUTIMESAT && !FUTIMESAT_NULL_BUG) || HAVE_FUTIMES | |
330 | # if HAVE_FUTIMESAT && !FUTIMESAT_NULL_BUG | |
331 | # undef futimes | |
332 | # define futimes(fd, t) futimesat (fd, NULL, t) | |
333 | # endif | |
334 | if (futimes (fd, t) == 0) | |
335 | { | |
336 | # if __linux__ && __GLIBC__ | |
337 | /* Work around a longstanding glibc bug, still present as | |
338 | of 2010-12-27. On older Linux kernels that lack both | |
339 | utimensat and utimes, glibc's futimes rounds instead of | |
340 | truncating when falling back on utime. The same bug | |
341 | occurs in futimesat with a null 2nd arg. */ | |
342 | if (t) | |
343 | { | |
344 | bool abig = 500000 <= t[0].tv_usec; | |
345 | bool mbig = 500000 <= t[1].tv_usec; | |
346 | if ((abig | mbig) && fstat (fd, &st) == 0) | |
347 | { | |
348 | /* If these two subtractions overflow, they'll | |
349 | track the overflows inside the buggy glibc. */ | |
350 | time_t adiff = st.st_atime - t[0].tv_sec; | |
351 | time_t mdiff = st.st_mtime - t[1].tv_sec; | |
352 | ||
353 | struct timeval *tt = NULL; | |
354 | struct timeval truncated_timeval[2]; | |
355 | truncated_timeval[0] = t[0]; | |
356 | truncated_timeval[1] = t[1]; | |
357 | if (abig && adiff == 1 && get_stat_atime_ns (&st) == 0) | |
358 | { | |
359 | tt = truncated_timeval; | |
360 | tt[0].tv_usec = 0; | |
361 | } | |
362 | if (mbig && mdiff == 1 && get_stat_mtime_ns (&st) == 0) | |
363 | { | |
364 | tt = truncated_timeval; | |
365 | tt[1].tv_usec = 0; | |
366 | } | |
367 | if (tt) | |
368 | futimes (fd, tt); | |
369 | } | |
370 | } | |
371 | # endif | |
372 | ||
373 | return 0; | |
374 | } | |
375 | # endif | |
376 | } | |
377 | #endif /* HAVE_FUTIMESAT || HAVE_WORKING_UTIMES */ | |
378 | ||
379 | if (!file) | |
380 | { | |
381 | #if ! ((HAVE_FUTIMESAT && !FUTIMESAT_NULL_BUG) \ | |
382 | || (HAVE_WORKING_UTIMES && HAVE_FUTIMES)) | |
383 | errno = ENOSYS; | |
384 | #endif | |
385 | return -1; | |
386 | } | |
387 | ||
388 | #if HAVE_WORKING_UTIMES | |
389 | return utimes (file, t); | |
390 | #else | |
391 | { | |
392 | struct utimbuf utimbuf; | |
393 | struct utimbuf *ut; | |
394 | if (ts) | |
395 | { | |
396 | utimbuf.actime = ts[0].tv_sec; | |
397 | utimbuf.modtime = ts[1].tv_sec; | |
398 | ut = &utimbuf; | |
399 | } | |
400 | else | |
401 | ut = NULL; | |
402 | ||
403 | return utime (file, ut); | |
404 | } | |
405 | #endif /* !HAVE_WORKING_UTIMES */ | |
406 | } | |
407 | } | |
408 | ||
409 | /* Set the access and modification time stamps of FILE to be | |
410 | TIMESPEC[0] and TIMESPEC[1], respectively. */ | |
411 | int | |
412 | utimens (char const *file, struct timespec const timespec[2]) | |
413 | { | |
414 | return fdutimens (-1, file, timespec); | |
415 | } | |
416 | ||
417 | /* Set the access and modification time stamps of FILE to be | |
418 | TIMESPEC[0] and TIMESPEC[1], respectively, without dereferencing | |
419 | symlinks. Fail with ENOSYS if the platform does not support | |
420 | changing symlink timestamps, but FILE was a symlink. */ | |
421 | int | |
422 | lutimens (char const *file, struct timespec const timespec[2]) | |
423 | { | |
424 | struct timespec adjusted_timespec[2]; | |
425 | struct timespec *ts = timespec ? adjusted_timespec : NULL; | |
426 | int adjustment_needed = 0; | |
427 | struct stat st; | |
428 | ||
429 | if (ts) | |
430 | { | |
431 | adjusted_timespec[0] = timespec[0]; | |
432 | adjusted_timespec[1] = timespec[1]; | |
433 | adjustment_needed = validate_timespec (ts); | |
434 | } | |
435 | if (adjustment_needed < 0) | |
436 | return -1; | |
437 | ||
438 | /* The Linux kernel did not support symlink timestamps until | |
439 | utimensat, in version 2.6.22, so we don't need to mimic | |
440 | fdutimens' worry about buggy NFS clients. But we do have to | |
441 | worry about bogus return values. */ | |
442 | ||
443 | #if HAVE_UTIMENSAT | |
444 | if (0 <= lutimensat_works_really) | |
445 | { | |
446 | int result; | |
447 | # if __linux__ | |
448 | /* As recently as Linux kernel 2.6.32 (Dec 2009), several file | |
449 | systems (xfs, ntfs-3g) have bugs with a single UTIME_OMIT, | |
450 | but work if both times are either explicitly specified or | |
451 | UTIME_NOW. Work around it with a preparatory lstat prior to | |
452 | calling utimensat; fortunately, there is not much timing | |
453 | impact due to the extra syscall even on file systems where | |
454 | UTIME_OMIT would have worked. FIXME: Simplify this in 2012, | |
455 | when file system bugs are no longer common. */ | |
456 | if (adjustment_needed == 2) | |
457 | { | |
458 | if (lstat (file, &st)) | |
459 | return -1; | |
460 | if (ts[0].tv_nsec == UTIME_OMIT) | |
461 | ts[0] = get_stat_atime (&st); | |
462 | else if (ts[1].tv_nsec == UTIME_OMIT) | |
463 | ts[1] = get_stat_mtime (&st); | |
464 | /* Note that st is good, in case utimensat gives ENOSYS. */ | |
465 | adjustment_needed++; | |
466 | } | |
467 | # endif /* __linux__ */ | |
468 | result = utimensat (AT_FDCWD, file, ts, AT_SYMLINK_NOFOLLOW); | |
469 | # ifdef __linux__ | |
470 | /* Work around a kernel bug: | |
471 | http://bugzilla.redhat.com/442352 | |
472 | http://bugzilla.redhat.com/449910 | |
473 | It appears that utimensat can mistakenly return 280 rather | |
474 | than -1 upon ENOSYS failure. | |
475 | FIXME: remove in 2010 or whenever the offending kernels | |
476 | are no longer in common use. */ | |
477 | if (0 < result) | |
478 | errno = ENOSYS; | |
479 | # endif | |
480 | if (result == 0 || errno != ENOSYS) | |
481 | { | |
482 | utimensat_works_really = 1; | |
483 | lutimensat_works_really = 1; | |
484 | return result; | |
485 | } | |
486 | } | |
487 | lutimensat_works_really = -1; | |
488 | #endif /* HAVE_UTIMENSAT */ | |
489 | ||
490 | /* The platform lacks an interface to set file timestamps with | |
491 | nanosecond resolution, so do the best we can, discarding any | |
492 | fractional part of the timestamp. */ | |
493 | ||
494 | if (adjustment_needed || REPLACE_FUNC_STAT_FILE) | |
495 | { | |
496 | if (adjustment_needed != 3 && lstat (file, &st)) | |
497 | return -1; | |
498 | if (ts && update_timespec (&st, &ts)) | |
499 | return 0; | |
500 | } | |
501 | ||
502 | /* On Linux, lutimes is a thin wrapper around utimensat, so there is | |
503 | no point trying lutimes if utimensat failed with ENOSYS. */ | |
504 | #if HAVE_LUTIMES && !HAVE_UTIMENSAT | |
505 | { | |
506 | struct timeval timeval[2]; | |
507 | struct timeval *t; | |
508 | int result; | |
509 | if (ts) | |
510 | { | |
511 | timeval[0].tv_sec = ts[0].tv_sec; | |
512 | timeval[0].tv_usec = ts[0].tv_nsec / 1000; | |
513 | timeval[1].tv_sec = ts[1].tv_sec; | |
514 | timeval[1].tv_usec = ts[1].tv_nsec / 1000; | |
515 | t = timeval; | |
516 | } | |
517 | else | |
518 | t = NULL; | |
519 | ||
520 | result = lutimes (file, t); | |
521 | if (result == 0 || errno != ENOSYS) | |
522 | return result; | |
523 | } | |
524 | #endif /* HAVE_LUTIMES && !HAVE_UTIMENSAT */ | |
525 | ||
526 | /* Out of luck for symlinks, but we still handle regular files. */ | |
527 | if (!(adjustment_needed || REPLACE_FUNC_STAT_FILE) && lstat (file, &st)) | |
528 | return -1; | |
529 | if (!S_ISLNK (st.st_mode)) | |
530 | return fdutimens (-1, file, ts); | |
531 | errno = ENOSYS; | |
532 | return -1; | |
533 | } |