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