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