blob: 32b15b3f6629023e55c34474bae0fa942a8df6ea [file] [log] [blame]
Alexey Dobriyan82b05472006-09-30 23:27:22 -07001#include <linux/compiler.h>
Ulrich Drepper1c710c82007-05-08 00:33:25 -07002#include <linux/file.h>
Alexey Dobriyan82b05472006-09-30 23:27:22 -07003#include <linux/fs.h>
4#include <linux/linkage.h>
Dave Hansen74f9fdf2008-02-15 14:37:42 -08005#include <linux/mount.h>
Alexey Dobriyan82b05472006-09-30 23:27:22 -07006#include <linux/namei.h>
Al Viro914e2632006-10-18 13:55:46 -04007#include <linux/sched.h>
Ulrich Drepper1c710c82007-05-08 00:33:25 -07008#include <linux/stat.h>
Alexey Dobriyan82b05472006-09-30 23:27:22 -07009#include <linux/utime.h>
Adrian Bunk12c2ab52008-02-06 01:36:47 -080010#include <linux/syscalls.h>
Linus Torvalds7c0f6ba2016-12-24 11:46:01 -080011#include <linux/uaccess.h>
Alexey Dobriyan82b05472006-09-30 23:27:22 -070012#include <asm/unistd.h>
13
14#ifdef __ARCH_WANT_SYS_UTIME
15
16/*
17 * sys_utime() can be implemented in user-level using sys_utimes().
18 * Is this for backwards compatibility? If so, why not move it
19 * into the appropriate arch directory (for those architectures that
20 * need it).
21 */
22
23/* If times==NULL, set access and modification to current time,
24 * must be owner or have write permission.
25 * Else, update from *times, must be owner or super user.
26 */
Heiko Carstens003d7ab2009-01-14 14:14:21 +010027SYSCALL_DEFINE2(utime, char __user *, filename, struct utimbuf __user *, times)
Alexey Dobriyan82b05472006-09-30 23:27:22 -070028{
Ulrich Drepper1c710c82007-05-08 00:33:25 -070029 struct timespec tv[2];
Alexey Dobriyan82b05472006-09-30 23:27:22 -070030
Alexey Dobriyan82b05472006-09-30 23:27:22 -070031 if (times) {
Ulrich Drepper1c710c82007-05-08 00:33:25 -070032 if (get_user(tv[0].tv_sec, &times->actime) ||
33 get_user(tv[1].tv_sec, &times->modtime))
34 return -EFAULT;
35 tv[0].tv_nsec = 0;
36 tv[1].tv_nsec = 0;
Alexey Dobriyan82b05472006-09-30 23:27:22 -070037 }
Ulrich Drepper1c710c82007-05-08 00:33:25 -070038 return do_utimes(AT_FDCWD, filename, times ? tv : NULL, 0);
Alexey Dobriyan82b05472006-09-30 23:27:22 -070039}
40
41#endif
42
Miklos Szeredi043f46f2007-10-16 23:27:07 -070043static bool nsec_valid(long nsec)
44{
Michael Kerrisk4cca9222008-06-09 21:16:08 -070045 if (nsec == UTIME_OMIT || nsec == UTIME_NOW)
Miklos Szeredi043f46f2007-10-16 23:27:07 -070046 return true;
47
48 return nsec >= 0 && nsec <= 999999999;
49}
50
Al Virof0bb5aa2016-11-20 20:27:12 -050051static int utimes_common(const struct path *path, struct timespec *times)
Alexey Dobriyan82b05472006-09-30 23:27:22 -070052{
53 int error;
Alexey Dobriyan82b05472006-09-30 23:27:22 -070054 struct iattr newattrs;
Miklos Szeredie9b76fe2008-07-01 15:01:27 +020055 struct inode *inode = path->dentry->d_inode;
J. Bruce Fields27ac0ff2011-09-20 17:19:26 -040056 struct inode *delegated_inode = NULL;
Alexey Dobriyan82b05472006-09-30 23:27:22 -070057
Miklos Szeredie9b76fe2008-07-01 15:01:27 +020058 error = mnt_want_write(path->mnt);
Dave Hansen74f9fdf2008-02-15 14:37:42 -080059 if (error)
Miklos Szeredie9b76fe2008-07-01 15:01:27 +020060 goto out;
Alexey Dobriyan82b05472006-09-30 23:27:22 -070061
Michael Kerrisk12fd0d32008-06-09 21:16:07 -070062 if (times && times[0].tv_nsec == UTIME_NOW &&
63 times[1].tv_nsec == UTIME_NOW)
64 times = NULL;
65
Alexey Dobriyan82b05472006-09-30 23:27:22 -070066 newattrs.ia_valid = ATTR_CTIME | ATTR_MTIME | ATTR_ATIME;
67 if (times) {
Ulrich Drepper1c710c82007-05-08 00:33:25 -070068 if (times[0].tv_nsec == UTIME_OMIT)
69 newattrs.ia_valid &= ~ATTR_ATIME;
70 else if (times[0].tv_nsec != UTIME_NOW) {
71 newattrs.ia_atime.tv_sec = times[0].tv_sec;
72 newattrs.ia_atime.tv_nsec = times[0].tv_nsec;
73 newattrs.ia_valid |= ATTR_ATIME_SET;
74 }
75
76 if (times[1].tv_nsec == UTIME_OMIT)
77 newattrs.ia_valid &= ~ATTR_MTIME;
78 else if (times[1].tv_nsec != UTIME_NOW) {
79 newattrs.ia_mtime.tv_sec = times[1].tv_sec;
80 newattrs.ia_mtime.tv_nsec = times[1].tv_nsec;
81 newattrs.ia_valid |= ATTR_MTIME_SET;
82 }
Michael Kerrisk4cca9222008-06-09 21:16:08 -070083 /*
Jan Kara31051c82016-05-26 16:55:18 +020084 * Tell setattr_prepare(), that this is an explicit time
Miklos Szeredi9767d742008-07-01 15:01:26 +020085 * update, even if neither ATTR_ATIME_SET nor ATTR_MTIME_SET
86 * were used.
Michael Kerrisk4cca9222008-06-09 21:16:08 -070087 */
Miklos Szeredi9767d742008-07-01 15:01:26 +020088 newattrs.ia_valid |= ATTR_TIMES_SET;
Michael Kerrisk4cca9222008-06-09 21:16:08 -070089 } else {
Miklos Szeredif2b20f62016-09-16 12:44:20 +020090 newattrs.ia_valid |= ATTR_TOUCH;
Alexey Dobriyan82b05472006-09-30 23:27:22 -070091 }
J. Bruce Fields27ac0ff2011-09-20 17:19:26 -040092retry_deleg:
Al Viro59551022016-01-22 15:40:57 -050093 inode_lock(inode);
J. Bruce Fields27ac0ff2011-09-20 17:19:26 -040094 error = notify_change(path->dentry, &newattrs, &delegated_inode);
Al Viro59551022016-01-22 15:40:57 -050095 inode_unlock(inode);
J. Bruce Fields27ac0ff2011-09-20 17:19:26 -040096 if (delegated_inode) {
97 error = break_deleg_wait(&delegated_inode);
98 if (!error)
99 goto retry_deleg;
100 }
Miklos Szeredie9b76fe2008-07-01 15:01:27 +0200101
Miklos Szeredie9b76fe2008-07-01 15:01:27 +0200102 mnt_drop_write(path->mnt);
103out:
104 return error;
105}
106
107/*
108 * do_utimes - change times on filename or file descriptor
109 * @dfd: open file descriptor, -1 or AT_FDCWD
110 * @filename: path name or NULL
111 * @times: new times or NULL
112 * @flags: zero or more flags (only AT_SYMLINK_NOFOLLOW for the moment)
113 *
114 * If filename is NULL and dfd refers to an open file, then operate on
115 * the file. Otherwise look up filename, possibly using dfd as a
116 * starting point.
117 *
118 * If times==NULL, set access and modification to current time,
119 * must be owner or have write permission.
120 * Else, update from *times, must be owner or super user.
121 */
David Howellsc7887322010-08-11 11:26:22 +0100122long do_utimes(int dfd, const char __user *filename, struct timespec *times,
123 int flags)
Miklos Szeredie9b76fe2008-07-01 15:01:27 +0200124{
125 int error = -EINVAL;
126
127 if (times && (!nsec_valid(times[0].tv_nsec) ||
128 !nsec_valid(times[1].tv_nsec))) {
129 goto out;
130 }
131
132 if (flags & ~AT_SYMLINK_NOFOLLOW)
133 goto out;
134
135 if (filename == NULL && dfd != AT_FDCWD) {
Al Viro2903ff02012-08-28 12:52:22 -0400136 struct fd f;
Miklos Szeredie9b76fe2008-07-01 15:01:27 +0200137
138 if (flags & AT_SYMLINK_NOFOLLOW)
139 goto out;
140
Al Viro2903ff02012-08-28 12:52:22 -0400141 f = fdget(dfd);
Miklos Szeredie9b76fe2008-07-01 15:01:27 +0200142 error = -EBADF;
Al Viro2903ff02012-08-28 12:52:22 -0400143 if (!f.file)
Miklos Szeredie9b76fe2008-07-01 15:01:27 +0200144 goto out;
145
Al Viro2903ff02012-08-28 12:52:22 -0400146 error = utimes_common(&f.file->f_path, times);
147 fdput(f);
Miklos Szeredie9b76fe2008-07-01 15:01:27 +0200148 } else {
Al Viro2d8f3032008-07-22 09:59:21 -0400149 struct path path;
Miklos Szeredie9b76fe2008-07-01 15:01:27 +0200150 int lookup_flags = 0;
151
152 if (!(flags & AT_SYMLINK_NOFOLLOW))
153 lookup_flags |= LOOKUP_FOLLOW;
Jeff Laytona69201d2012-12-11 12:10:14 -0500154retry:
Al Viro2d8f3032008-07-22 09:59:21 -0400155 error = user_path_at(dfd, filename, lookup_flags, &path);
Miklos Szeredie9b76fe2008-07-01 15:01:27 +0200156 if (error)
157 goto out;
158
Al Viro2d8f3032008-07-22 09:59:21 -0400159 error = utimes_common(&path, times);
160 path_put(&path);
Jeff Laytona69201d2012-12-11 12:10:14 -0500161 if (retry_estale(error, lookup_flags)) {
162 lookup_flags |= LOOKUP_REVAL;
163 goto retry;
164 }
Miklos Szeredie9b76fe2008-07-01 15:01:27 +0200165 }
166
Alexey Dobriyan82b05472006-09-30 23:27:22 -0700167out:
168 return error;
169}
170
David Howellsc7887322010-08-11 11:26:22 +0100171SYSCALL_DEFINE4(utimensat, int, dfd, const char __user *, filename,
Heiko Carstens6559eed82009-01-14 14:14:32 +0100172 struct timespec __user *, utimes, int, flags)
Ulrich Drepper1c710c82007-05-08 00:33:25 -0700173{
174 struct timespec tstimes[2];
175
176 if (utimes) {
177 if (copy_from_user(&tstimes, utimes, sizeof(tstimes)))
178 return -EFAULT;
Ulrich Drepper1c710c82007-05-08 00:33:25 -0700179
180 /* Nothing to do, we must not even check the path. */
181 if (tstimes[0].tv_nsec == UTIME_OMIT &&
182 tstimes[1].tv_nsec == UTIME_OMIT)
183 return 0;
184 }
185
186 return do_utimes(dfd, filename, utimes ? tstimes : NULL, flags);
187}
188
David Howellsc7887322010-08-11 11:26:22 +0100189SYSCALL_DEFINE3(futimesat, int, dfd, const char __user *, filename,
Heiko Carstens6559eed82009-01-14 14:14:32 +0100190 struct timeval __user *, utimes)
Alexey Dobriyan82b05472006-09-30 23:27:22 -0700191{
192 struct timeval times[2];
Ulrich Drepper1c710c82007-05-08 00:33:25 -0700193 struct timespec tstimes[2];
Alexey Dobriyan82b05472006-09-30 23:27:22 -0700194
Ulrich Drepper1c710c82007-05-08 00:33:25 -0700195 if (utimes) {
196 if (copy_from_user(&times, utimes, sizeof(times)))
197 return -EFAULT;
198
199 /* This test is needed to catch all invalid values. If we
200 would test only in do_utimes we would miss those invalid
201 values truncated by the multiplication with 1000. Note
202 that we also catch UTIME_{NOW,OMIT} here which are only
203 valid for utimensat. */
204 if (times[0].tv_usec >= 1000000 || times[0].tv_usec < 0 ||
205 times[1].tv_usec >= 1000000 || times[1].tv_usec < 0)
206 return -EINVAL;
207
208 tstimes[0].tv_sec = times[0].tv_sec;
209 tstimes[0].tv_nsec = 1000 * times[0].tv_usec;
210 tstimes[1].tv_sec = times[1].tv_sec;
211 tstimes[1].tv_nsec = 1000 * times[1].tv_usec;
212 }
213
214 return do_utimes(dfd, filename, utimes ? tstimes : NULL, 0);
Alexey Dobriyan82b05472006-09-30 23:27:22 -0700215}
216
Heiko Carstens003d7ab2009-01-14 14:14:21 +0100217SYSCALL_DEFINE2(utimes, char __user *, filename,
218 struct timeval __user *, utimes)
Alexey Dobriyan82b05472006-09-30 23:27:22 -0700219{
220 return sys_futimesat(AT_FDCWD, filename, utimes);
221}