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 = times[0]; 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 = times[1]; 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 | AT_EMPTY_PATH)) 99 goto out; 100 101 if (filename == NULL && dfd != AT_FDCWD) { 102 struct fd f; 103 104 if (flags) 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 if (flags & AT_EMPTY_PATH) 121 lookup_flags |= LOOKUP_EMPTY; 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 __kernel_old_timeval __user *utimes) 167 { 168 struct __kernel_old_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 __kernel_old_timeval __user *, utimes) 196 { 197 return do_futimesat(dfd, filename, utimes); 198 } 199 200 SYSCALL_DEFINE2(utimes, char __user *, filename, 201 struct __kernel_old_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 SYSCALL_DEFINE2(utime32, 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 SYSCALL_DEFINE4(utimensat_time32, 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 SYSCALL_DEFINE3(futimesat_time32, 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 SYSCALL_DEFINE2(utimes_time32, 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