Merge tag 'perf-urgent-for-mingo-4.14-20170928' of git://git.kernel.org/pub/scm/linux...
[sfrench/cifs-2.6.git] / fs / utimes.c
1 #include <linux/file.h>
2 #include <linux/mount.h>
3 #include <linux/namei.h>
4 #include <linux/utime.h>
5 #include <linux/syscalls.h>
6 #include <linux/uaccess.h>
7 #include <linux/compat.h>
8 #include <asm/unistd.h>
9
10 #ifdef __ARCH_WANT_SYS_UTIME
11
12 /*
13  * sys_utime() can be implemented in user-level using sys_utimes().
14  * Is this for backwards compatibility?  If so, why not move it
15  * into the appropriate arch directory (for those architectures that
16  * need it).
17  */
18
19 /* If times==NULL, set access and modification to current time,
20  * must be owner or have write permission.
21  * Else, update from *times, must be owner or super user.
22  */
23 SYSCALL_DEFINE2(utime, char __user *, filename, struct utimbuf __user *, times)
24 {
25         struct timespec64 tv[2];
26
27         if (times) {
28                 if (get_user(tv[0].tv_sec, &times->actime) ||
29                     get_user(tv[1].tv_sec, &times->modtime))
30                         return -EFAULT;
31                 tv[0].tv_nsec = 0;
32                 tv[1].tv_nsec = 0;
33         }
34         return do_utimes(AT_FDCWD, filename, times ? tv : NULL, 0);
35 }
36
37 #endif
38
39 static bool nsec_valid(long nsec)
40 {
41         if (nsec == UTIME_OMIT || nsec == UTIME_NOW)
42                 return true;
43
44         return nsec >= 0 && nsec <= 999999999;
45 }
46
47 static int utimes_common(const struct path *path, struct timespec64 *times)
48 {
49         int error;
50         struct iattr newattrs;
51         struct inode *inode = path->dentry->d_inode;
52         struct inode *delegated_inode = NULL;
53
54         error = mnt_want_write(path->mnt);
55         if (error)
56                 goto out;
57
58         if (times && times[0].tv_nsec == UTIME_NOW &&
59                      times[1].tv_nsec == UTIME_NOW)
60                 times = NULL;
61
62         newattrs.ia_valid = ATTR_CTIME | ATTR_MTIME | ATTR_ATIME;
63         if (times) {
64                 if (times[0].tv_nsec == UTIME_OMIT)
65                         newattrs.ia_valid &= ~ATTR_ATIME;
66                 else if (times[0].tv_nsec != UTIME_NOW) {
67                         newattrs.ia_atime.tv_sec = times[0].tv_sec;
68                         newattrs.ia_atime.tv_nsec = times[0].tv_nsec;
69                         newattrs.ia_valid |= ATTR_ATIME_SET;
70                 }
71
72                 if (times[1].tv_nsec == UTIME_OMIT)
73                         newattrs.ia_valid &= ~ATTR_MTIME;
74                 else if (times[1].tv_nsec != UTIME_NOW) {
75                         newattrs.ia_mtime.tv_sec = times[1].tv_sec;
76                         newattrs.ia_mtime.tv_nsec = times[1].tv_nsec;
77                         newattrs.ia_valid |= ATTR_MTIME_SET;
78                 }
79                 /*
80                  * Tell setattr_prepare(), that this is an explicit time
81                  * update, even if neither ATTR_ATIME_SET nor ATTR_MTIME_SET
82                  * were used.
83                  */
84                 newattrs.ia_valid |= ATTR_TIMES_SET;
85         } else {
86                 newattrs.ia_valid |= ATTR_TOUCH;
87         }
88 retry_deleg:
89         inode_lock(inode);
90         error = notify_change(path->dentry, &newattrs, &delegated_inode);
91         inode_unlock(inode);
92         if (delegated_inode) {
93                 error = break_deleg_wait(&delegated_inode);
94                 if (!error)
95                         goto retry_deleg;
96         }
97
98         mnt_drop_write(path->mnt);
99 out:
100         return error;
101 }
102
103 /*
104  * do_utimes - change times on filename or file descriptor
105  * @dfd: open file descriptor, -1 or AT_FDCWD
106  * @filename: path name or NULL
107  * @times: new times or NULL
108  * @flags: zero or more flags (only AT_SYMLINK_NOFOLLOW for the moment)
109  *
110  * If filename is NULL and dfd refers to an open file, then operate on
111  * the file.  Otherwise look up filename, possibly using dfd as a
112  * starting point.
113  *
114  * If times==NULL, set access and modification to current time,
115  * must be owner or have write permission.
116  * Else, update from *times, must be owner or super user.
117  */
118 long do_utimes(int dfd, const char __user *filename, struct timespec64 *times,
119                int flags)
120 {
121         int error = -EINVAL;
122
123         if (times && (!nsec_valid(times[0].tv_nsec) ||
124                       !nsec_valid(times[1].tv_nsec))) {
125                 goto out;
126         }
127
128         if (flags & ~AT_SYMLINK_NOFOLLOW)
129                 goto out;
130
131         if (filename == NULL && dfd != AT_FDCWD) {
132                 struct fd f;
133
134                 if (flags & AT_SYMLINK_NOFOLLOW)
135                         goto out;
136
137                 f = fdget(dfd);
138                 error = -EBADF;
139                 if (!f.file)
140                         goto out;
141
142                 error = utimes_common(&f.file->f_path, times);
143                 fdput(f);
144         } else {
145                 struct path path;
146                 int lookup_flags = 0;
147
148                 if (!(flags & AT_SYMLINK_NOFOLLOW))
149                         lookup_flags |= LOOKUP_FOLLOW;
150 retry:
151                 error = user_path_at(dfd, filename, lookup_flags, &path);
152                 if (error)
153                         goto out;
154
155                 error = utimes_common(&path, times);
156                 path_put(&path);
157                 if (retry_estale(error, lookup_flags)) {
158                         lookup_flags |= LOOKUP_REVAL;
159                         goto retry;
160                 }
161         }
162
163 out:
164         return error;
165 }
166
167 SYSCALL_DEFINE4(utimensat, int, dfd, const char __user *, filename,
168                 struct timespec __user *, utimes, int, flags)
169 {
170         struct timespec64 tstimes[2];
171
172         if (utimes) {
173                 if ((get_timespec64(&tstimes[0], &utimes[0]) ||
174                         get_timespec64(&tstimes[1], &utimes[1])))
175                         return -EFAULT;
176
177                 /* Nothing to do, we must not even check the path.  */
178                 if (tstimes[0].tv_nsec == UTIME_OMIT &&
179                     tstimes[1].tv_nsec == UTIME_OMIT)
180                         return 0;
181         }
182
183         return do_utimes(dfd, filename, utimes ? tstimes : NULL, flags);
184 }
185
186 SYSCALL_DEFINE3(futimesat, int, dfd, const char __user *, filename,
187                 struct timeval __user *, utimes)
188 {
189         struct timeval times[2];
190         struct timespec64 tstimes[2];
191
192         if (utimes) {
193                 if (copy_from_user(&times, utimes, sizeof(times)))
194                         return -EFAULT;
195
196                 /* This test is needed to catch all invalid values.  If we
197                    would test only in do_utimes we would miss those invalid
198                    values truncated by the multiplication with 1000.  Note
199                    that we also catch UTIME_{NOW,OMIT} here which are only
200                    valid for utimensat.  */
201                 if (times[0].tv_usec >= 1000000 || times[0].tv_usec < 0 ||
202                     times[1].tv_usec >= 1000000 || times[1].tv_usec < 0)
203                         return -EINVAL;
204
205                 tstimes[0].tv_sec = times[0].tv_sec;
206                 tstimes[0].tv_nsec = 1000 * times[0].tv_usec;
207                 tstimes[1].tv_sec = times[1].tv_sec;
208                 tstimes[1].tv_nsec = 1000 * times[1].tv_usec;
209         }
210
211         return do_utimes(dfd, filename, utimes ? tstimes : NULL, 0);
212 }
213
214 SYSCALL_DEFINE2(utimes, char __user *, filename,
215                 struct timeval __user *, utimes)
216 {
217         return sys_futimesat(AT_FDCWD, filename, utimes);
218 }
219
220 #ifdef CONFIG_COMPAT
221 /*
222  * Not all architectures have sys_utime, so implement this in terms
223  * of sys_utimes.
224  */
225 COMPAT_SYSCALL_DEFINE2(utime, const char __user *, filename,
226                        struct compat_utimbuf __user *, t)
227 {
228         struct timespec64 tv[2];
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 }
239
240 COMPAT_SYSCALL_DEFINE4(utimensat, unsigned int, dfd, const char __user *, filename, struct compat_timespec __user *, t, int, flags)
241 {
242         struct timespec64 tv[2];
243
244         if  (t) {
245                 if (compat_get_timespec64(&tv[0], &t[0]) ||
246                     compat_get_timespec64(&tv[1], &t[1]))
247                         return -EFAULT;
248
249                 if (tv[0].tv_nsec == UTIME_OMIT && tv[1].tv_nsec == UTIME_OMIT)
250                         return 0;
251         }
252         return do_utimes(dfd, filename, t ? tv : NULL, flags);
253 }
254
255 COMPAT_SYSCALL_DEFINE3(futimesat, unsigned int, dfd, const char __user *, filename, struct compat_timeval __user *, t)
256 {
257         struct timespec64 tv[2];
258
259         if (t) {
260                 if (get_user(tv[0].tv_sec, &t[0].tv_sec) ||
261                     get_user(tv[0].tv_nsec, &t[0].tv_usec) ||
262                     get_user(tv[1].tv_sec, &t[1].tv_sec) ||
263                     get_user(tv[1].tv_nsec, &t[1].tv_usec))
264                         return -EFAULT;
265                 if (tv[0].tv_nsec >= 1000000 || tv[0].tv_nsec < 0 ||
266                     tv[1].tv_nsec >= 1000000 || tv[1].tv_nsec < 0)
267                         return -EINVAL;
268                 tv[0].tv_nsec *= 1000;
269                 tv[1].tv_nsec *= 1000;
270         }
271         return do_utimes(dfd, filename, t ? tv : NULL, 0);
272 }
273
274 COMPAT_SYSCALL_DEFINE2(utimes, const char __user *, filename, struct compat_timeval __user *, t)
275 {
276         return compat_sys_futimesat(AT_FDCWD, filename, t);
277 }
278 #endif