fs/utimes.c

   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(&times, 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, &times->actime) ||
 219                     get_user(tv[1].tv_sec, &times->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