]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1c710c89 | 2 | #include <linux/file.h> |
74f9fdfa | 3 | #include <linux/mount.h> |
82b0547c AD |
4 | #include <linux/namei.h> |
5 | #include <linux/utime.h> | |
12c2ab5e | 6 | #include <linux/syscalls.h> |
7c0f6ba6 | 7 | #include <linux/uaccess.h> |
1a060ba3 | 8 | #include <linux/compat.h> |
82b0547c AD |
9 | #include <asm/unistd.h> |
10 | ||
043f46f6 MS |
11 | static bool nsec_valid(long nsec) |
12 | { | |
4cca9226 | 13 | if (nsec == UTIME_OMIT || nsec == UTIME_NOW) |
043f46f6 MS |
14 | return true; |
15 | ||
16 | return nsec >= 0 && nsec <= 999999999; | |
17 | } | |
18 | ||
aaed2dd8 | 19 | static int utimes_common(const struct path *path, struct timespec64 *times) |
82b0547c AD |
20 | { |
21 | int error; | |
82b0547c | 22 | struct iattr newattrs; |
e9b76fed | 23 | struct inode *inode = path->dentry->d_inode; |
27ac0ffe | 24 | struct inode *delegated_inode = NULL; |
82b0547c | 25 | |
e9b76fed | 26 | error = mnt_want_write(path->mnt); |
74f9fdfa | 27 | if (error) |
e9b76fed | 28 | goto out; |
82b0547c | 29 | |
12fd0d30 MK |
30 | if (times && times[0].tv_nsec == UTIME_NOW && |
31 | times[1].tv_nsec == UTIME_NOW) | |
32 | times = NULL; | |
33 | ||
82b0547c AD |
34 | newattrs.ia_valid = ATTR_CTIME | ATTR_MTIME | ATTR_ATIME; |
35 | if (times) { | |
1c710c89 UD |
36 | if (times[0].tv_nsec == UTIME_OMIT) |
37 | newattrs.ia_valid &= ~ATTR_ATIME; | |
38 | else if (times[0].tv_nsec != UTIME_NOW) { | |
42e729b9 | 39 | newattrs.ia_atime = timestamp_truncate(times[0], inode); |
1c710c89 UD |
40 | newattrs.ia_valid |= ATTR_ATIME_SET; |
41 | } | |
42 | ||
43 | if (times[1].tv_nsec == UTIME_OMIT) | |
44 | newattrs.ia_valid &= ~ATTR_MTIME; | |
45 | else if (times[1].tv_nsec != UTIME_NOW) { | |
42e729b9 | 46 | newattrs.ia_mtime = timestamp_truncate(times[1], inode); |
1c710c89 UD |
47 | newattrs.ia_valid |= ATTR_MTIME_SET; |
48 | } | |
4cca9226 | 49 | /* |
31051c85 | 50 | * Tell setattr_prepare(), that this is an explicit time |
9767d749 MS |
51 | * update, even if neither ATTR_ATIME_SET nor ATTR_MTIME_SET |
52 | * were used. | |
4cca9226 | 53 | */ |
9767d749 | 54 | newattrs.ia_valid |= ATTR_TIMES_SET; |
4cca9226 | 55 | } else { |
f2b20f6e | 56 | newattrs.ia_valid |= ATTR_TOUCH; |
82b0547c | 57 | } |
27ac0ffe | 58 | retry_deleg: |
5955102c | 59 | inode_lock(inode); |
27ac0ffe | 60 | error = notify_change(path->dentry, &newattrs, &delegated_inode); |
5955102c | 61 | inode_unlock(inode); |
27ac0ffe BF |
62 | if (delegated_inode) { |
63 | error = break_deleg_wait(&delegated_inode); | |
64 | if (!error) | |
65 | goto retry_deleg; | |
66 | } | |
e9b76fed | 67 | |
e9b76fed MS |
68 | mnt_drop_write(path->mnt); |
69 | out: | |
70 | return error; | |
71 | } | |
72 | ||
73 | /* | |
74 | * do_utimes - change times on filename or file descriptor | |
75 | * @dfd: open file descriptor, -1 or AT_FDCWD | |
76 | * @filename: path name or NULL | |
77 | * @times: new times or NULL | |
78 | * @flags: zero or more flags (only AT_SYMLINK_NOFOLLOW for the moment) | |
79 | * | |
80 | * If filename is NULL and dfd refers to an open file, then operate on | |
81 | * the file. Otherwise look up filename, possibly using dfd as a | |
82 | * starting point. | |
83 | * | |
84 | * If times==NULL, set access and modification to current time, | |
85 | * must be owner or have write permission. | |
86 | * Else, update from *times, must be owner or super user. | |
87 | */ | |
aaed2dd8 | 88 | long do_utimes(int dfd, const char __user *filename, struct timespec64 *times, |
c7887325 | 89 | int flags) |
e9b76fed MS |
90 | { |
91 | int error = -EINVAL; | |
92 | ||
93 | if (times && (!nsec_valid(times[0].tv_nsec) || | |
94 | !nsec_valid(times[1].tv_nsec))) { | |
95 | goto out; | |
96 | } | |
97 | ||
98 | if (flags & ~AT_SYMLINK_NOFOLLOW) | |
99 | goto out; | |
100 | ||
101 | if (filename == NULL && dfd != AT_FDCWD) { | |
2903ff01 | 102 | struct fd f; |
e9b76fed MS |
103 | |
104 | if (flags & AT_SYMLINK_NOFOLLOW) | |
105 | goto out; | |
106 | ||
2903ff01 | 107 | f = fdget(dfd); |
e9b76fed | 108 | error = -EBADF; |
2903ff01 | 109 | if (!f.file) |
e9b76fed MS |
110 | goto out; |
111 | ||
2903ff01 AV |
112 | error = utimes_common(&f.file->f_path, times); |
113 | fdput(f); | |
e9b76fed | 114 | } else { |
2d8f3038 | 115 | struct path path; |
e9b76fed MS |
116 | int lookup_flags = 0; |
117 | ||
118 | if (!(flags & AT_SYMLINK_NOFOLLOW)) | |
119 | lookup_flags |= LOOKUP_FOLLOW; | |
a69201d6 | 120 | retry: |
2d8f3038 | 121 | error = user_path_at(dfd, filename, lookup_flags, &path); |
e9b76fed MS |
122 | if (error) |
123 | goto out; | |
124 | ||
2d8f3038 AV |
125 | error = utimes_common(&path, times); |
126 | path_put(&path); | |
a69201d6 JL |
127 | if (retry_estale(error, lookup_flags)) { |
128 | lookup_flags |= LOOKUP_REVAL; | |
129 | goto retry; | |
130 | } | |
e9b76fed MS |
131 | } |
132 | ||
82b0547c AD |
133 | out: |
134 | return error; | |
135 | } | |
136 | ||
c7887325 | 137 | SYSCALL_DEFINE4(utimensat, int, dfd, const char __user *, filename, |
a4f7a300 | 138 | struct __kernel_timespec __user *, utimes, int, flags) |
1c710c89 | 139 | { |
aaed2dd8 | 140 | struct timespec64 tstimes[2]; |
1c710c89 UD |
141 | |
142 | if (utimes) { | |
aaed2dd8 DD |
143 | if ((get_timespec64(&tstimes[0], &utimes[0]) || |
144 | get_timespec64(&tstimes[1], &utimes[1]))) | |
1c710c89 | 145 | return -EFAULT; |
1c710c89 UD |
146 | |
147 | /* Nothing to do, we must not even check the path. */ | |
148 | if (tstimes[0].tv_nsec == UTIME_OMIT && | |
149 | tstimes[1].tv_nsec == UTIME_OMIT) | |
150 | return 0; | |
151 | } | |
152 | ||
153 | return do_utimes(dfd, filename, utimes ? tstimes : NULL, flags); | |
154 | } | |
155 | ||
185cfaf7 AB |
156 | #ifdef __ARCH_WANT_SYS_UTIME |
157 | /* | |
158 | * futimesat(), utimes() and utime() are older versions of utimensat() | |
159 | * that are provided for compatibility with traditional C libraries. | |
160 | * On modern architectures, we always use libc wrappers around | |
161 | * utimensat() instead. | |
162 | */ | |
f1390358 DB |
163 | static long do_futimesat(int dfd, const char __user *filename, |
164 | struct timeval __user *utimes) | |
82b0547c AD |
165 | { |
166 | struct timeval times[2]; | |
aaed2dd8 | 167 | struct timespec64 tstimes[2]; |
1c710c89 UD |
168 | |
169 | if (utimes) { | |
170 | if (copy_from_user(×, utimes, sizeof(times))) | |
171 | return -EFAULT; | |
172 | ||
173 | /* This test is needed to catch all invalid values. If we | |
174 | would test only in do_utimes we would miss those invalid | |
175 | values truncated by the multiplication with 1000. Note | |
176 | that we also catch UTIME_{NOW,OMIT} here which are only | |
177 | valid for utimensat. */ | |
178 | if (times[0].tv_usec >= 1000000 || times[0].tv_usec < 0 || | |
179 | times[1].tv_usec >= 1000000 || times[1].tv_usec < 0) | |
180 | return -EINVAL; | |
181 | ||
182 | tstimes[0].tv_sec = times[0].tv_sec; | |
183 | tstimes[0].tv_nsec = 1000 * times[0].tv_usec; | |
184 | tstimes[1].tv_sec = times[1].tv_sec; | |
185 | tstimes[1].tv_nsec = 1000 * times[1].tv_usec; | |
186 | } | |
82b0547c | 187 | |
1c710c89 | 188 | return do_utimes(dfd, filename, utimes ? tstimes : NULL, 0); |
82b0547c AD |
189 | } |
190 | ||
f1390358 DB |
191 | |
192 | SYSCALL_DEFINE3(futimesat, int, dfd, const char __user *, filename, | |
193 | struct timeval __user *, utimes) | |
194 | { | |
195 | return do_futimesat(dfd, filename, utimes); | |
196 | } | |
197 | ||
003d7ab4 HC |
198 | SYSCALL_DEFINE2(utimes, char __user *, filename, |
199 | struct timeval __user *, utimes) | |
82b0547c | 200 | { |
f1390358 | 201 | return do_futimesat(AT_FDCWD, filename, utimes); |
82b0547c | 202 | } |
1a060ba3 | 203 | |
185cfaf7 AB |
204 | SYSCALL_DEFINE2(utime, char __user *, filename, struct utimbuf __user *, times) |
205 | { | |
206 | struct timespec64 tv[2]; | |
207 | ||
208 | if (times) { | |
209 | if (get_user(tv[0].tv_sec, ×->actime) || | |
210 | get_user(tv[1].tv_sec, ×->modtime)) | |
211 | return -EFAULT; | |
212 | tv[0].tv_nsec = 0; | |
213 | tv[1].tv_nsec = 0; | |
214 | } | |
215 | return do_utimes(AT_FDCWD, filename, times ? tv : NULL, 0); | |
216 | } | |
217 | #endif | |
218 | ||
4faea239 | 219 | #ifdef CONFIG_COMPAT_32BIT_TIME |
1a060ba3 AV |
220 | /* |
221 | * Not all architectures have sys_utime, so implement this in terms | |
222 | * of sys_utimes. | |
223 | */ | |
4faea239 | 224 | #ifdef __ARCH_WANT_SYS_UTIME32 |
8dabe724 AB |
225 | SYSCALL_DEFINE2(utime32, const char __user *, filename, |
226 | struct old_utimbuf32 __user *, t) | |
1a060ba3 | 227 | { |
aaed2dd8 | 228 | struct timespec64 tv[2]; |
1a060ba3 AV |
229 | |
230 | if (t) { | |
231 | if (get_user(tv[0].tv_sec, &t->actime) || | |
232 | get_user(tv[1].tv_sec, &t->modtime)) | |
233 | return -EFAULT; | |
234 | tv[0].tv_nsec = 0; | |
235 | tv[1].tv_nsec = 0; | |
236 | } | |
237 | return do_utimes(AT_FDCWD, filename, t ? tv : NULL, 0); | |
238 | } | |
4faea239 | 239 | #endif |
1a060ba3 | 240 | |
8dabe724 | 241 | SYSCALL_DEFINE4(utimensat_time32, unsigned int, dfd, const char __user *, filename, struct old_timespec32 __user *, t, int, flags) |
1a060ba3 | 242 | { |
aaed2dd8 | 243 | struct timespec64 tv[2]; |
1a060ba3 AV |
244 | |
245 | if (t) { | |
9afc5eee AB |
246 | if (get_old_timespec32(&tv[0], &t[0]) || |
247 | get_old_timespec32(&tv[1], &t[1])) | |
1a060ba3 AV |
248 | return -EFAULT; |
249 | ||
250 | if (tv[0].tv_nsec == UTIME_OMIT && tv[1].tv_nsec == UTIME_OMIT) | |
251 | return 0; | |
252 | } | |
253 | return do_utimes(dfd, filename, t ? tv : NULL, flags); | |
254 | } | |
255 | ||
4faea239 | 256 | #ifdef __ARCH_WANT_SYS_UTIME32 |
ab641afa | 257 | static long do_compat_futimesat(unsigned int dfd, const char __user *filename, |
9afc5eee | 258 | struct old_timeval32 __user *t) |
1a060ba3 | 259 | { |
aaed2dd8 | 260 | struct timespec64 tv[2]; |
1a060ba3 AV |
261 | |
262 | if (t) { | |
263 | if (get_user(tv[0].tv_sec, &t[0].tv_sec) || | |
264 | get_user(tv[0].tv_nsec, &t[0].tv_usec) || | |
265 | get_user(tv[1].tv_sec, &t[1].tv_sec) || | |
266 | get_user(tv[1].tv_nsec, &t[1].tv_usec)) | |
267 | return -EFAULT; | |
268 | if (tv[0].tv_nsec >= 1000000 || tv[0].tv_nsec < 0 || | |
269 | tv[1].tv_nsec >= 1000000 || tv[1].tv_nsec < 0) | |
270 | return -EINVAL; | |
271 | tv[0].tv_nsec *= 1000; | |
272 | tv[1].tv_nsec *= 1000; | |
273 | } | |
274 | return do_utimes(dfd, filename, t ? tv : NULL, 0); | |
275 | } | |
276 | ||
8dabe724 | 277 | SYSCALL_DEFINE3(futimesat_time32, unsigned int, dfd, |
ab641afa | 278 | const char __user *, filename, |
9afc5eee | 279 | struct old_timeval32 __user *, t) |
ab641afa DB |
280 | { |
281 | return do_compat_futimesat(dfd, filename, t); | |
282 | } | |
283 | ||
8dabe724 | 284 | SYSCALL_DEFINE2(utimes_time32, const char __user *, filename, struct old_timeval32 __user *, t) |
1a060ba3 | 285 | { |
ab641afa | 286 | return do_compat_futimesat(AT_FDCWD, filename, t); |
1a060ba3 AV |
287 | } |
288 | #endif | |
4faea239 | 289 | #endif |