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