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 = timestamp_truncate(times[0], inode); 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) { 46 newattrs.ia_mtime = timestamp_truncate(times[1], inode); 47 newattrs.ia_valid |= ATTR_MTIME_SET; 48 } 49 /* 50 * Tell setattr_prepare(), that this is an explicit time 51 * update, even if neither ATTR_ATIME_SET nor ATTR_MTIME_SET 52 * were used. 53 */ 54 newattrs.ia_valid |= ATTR_TIMES_SET; 55 } else { 56 newattrs.ia_valid |= ATTR_TOUCH; 57 } 58 retry_deleg: 59 inode_lock(inode); 60 error = notify_change(path->dentry, &newattrs, &delegated_inode); 61 inode_unlock(inode); 62 if (delegated_inode) { 63 error = break_deleg_wait(&delegated_inode); 64 if (!error) 65 goto retry_deleg; 66 } 67 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 */ 88 long do_utimes(int dfd, const char __user *filename, struct timespec64 *times, 89 int flags) 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) { 102 struct fd f; 103 104 if (flags & AT_SYMLINK_NOFOLLOW) 105 goto out; 106 107 f = fdget(dfd); 108 error = -EBADF; 109 if (!f.file) 110 goto out; 111 112 error = utimes_common(&f.file->f_path, times); 113 fdput(f); 114 } else { 115 struct path path; 116 int lookup_flags = 0; 117 118 if (!(flags & AT_SYMLINK_NOFOLLOW)) 119 lookup_flags |= LOOKUP_FOLLOW; 120 retry: 121 error = user_path_at(dfd, filename, lookup_flags, &path); 122 if (error) 123 goto out; 124 125 error = utimes_common(&path, times); 126 path_put(&path); 127 if (retry_estale(error, lookup_flags)) { 128 lookup_flags |= LOOKUP_REVAL; 129 goto retry; 130 } 131 } 132 133 out: 134 return error; 135 } 136 137 SYSCALL_DEFINE4(utimensat, int, dfd, const char __user *, filename, 138 struct __kernel_timespec __user *, utimes, int, flags) 139 { 140 struct timespec64 tstimes[2]; 141 142 if (utimes) { 143 if ((get_timespec64(&tstimes[0], &utimes[0]) || 144 get_timespec64(&tstimes[1], &utimes[1]))) 145 return -EFAULT; 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 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 */ 163 static long do_futimesat(int dfd, const char __user *filename, 164 struct __kernel_old_timeval __user *utimes) 165 { 166 struct __kernel_old_timeval times[2]; 167 struct timespec64 tstimes[2]; 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 } 187 188 return do_utimes(dfd, filename, utimes ? tstimes : NULL, 0); 189 } 190 191 192 SYSCALL_DEFINE3(futimesat, int, dfd, const char __user *, filename, 193 struct __kernel_old_timeval __user *, utimes) 194 { 195 return do_futimesat(dfd, filename, utimes); 196 } 197 198 SYSCALL_DEFINE2(utimes, char __user *, filename, 199 struct __kernel_old_timeval __user *, utimes) 200 { 201 return do_futimesat(AT_FDCWD, filename, utimes); 202 } 203 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 219 #ifdef CONFIG_COMPAT_32BIT_TIME 220 /* 221 * Not all architectures have sys_utime, so implement this in terms 222 * of sys_utimes. 223 */ 224 #ifdef __ARCH_WANT_SYS_UTIME32 225 SYSCALL_DEFINE2(utime32, const char __user *, filename, 226 struct old_utimbuf32 __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 #endif 240 241 SYSCALL_DEFINE4(utimensat_time32, unsigned int, dfd, const char __user *, filename, struct old_timespec32 __user *, t, int, flags) 242 { 243 struct timespec64 tv[2]; 244 245 if (t) { 246 if (get_old_timespec32(&tv[0], &t[0]) || 247 get_old_timespec32(&tv[1], &t[1])) 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 256 #ifdef __ARCH_WANT_SYS_UTIME32 257 static long do_compat_futimesat(unsigned int dfd, const char __user *filename, 258 struct old_timeval32 __user *t) 259 { 260 struct timespec64 tv[2]; 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 277 SYSCALL_DEFINE3(futimesat_time32, unsigned int, dfd, 278 const char __user *, filename, 279 struct old_timeval32 __user *, t) 280 { 281 return do_compat_futimesat(dfd, filename, t); 282 } 283 284 SYSCALL_DEFINE2(utimes_time32, const char __user *, filename, struct old_timeval32 __user *, t) 285 { 286 return do_compat_futimesat(AT_FDCWD, filename, t); 287 } 288 #endif 289 #endif 290