1 #include <linux/compiler.h> 2 #include <linux/file.h> 3 #include <linux/fs.h> 4 #include <linux/linkage.h> 5 #include <linux/namei.h> 6 #include <linux/sched.h> 7 #include <linux/stat.h> 8 #include <linux/utime.h> 9 #include <asm/uaccess.h> 10 #include <asm/unistd.h> 11 12 #ifdef __ARCH_WANT_SYS_UTIME 13 14 /* 15 * sys_utime() can be implemented in user-level using sys_utimes(). 16 * Is this for backwards compatibility? If so, why not move it 17 * into the appropriate arch directory (for those architectures that 18 * need it). 19 */ 20 21 /* If times==NULL, set access and modification to current time, 22 * must be owner or have write permission. 23 * Else, update from *times, must be owner or super user. 24 */ 25 asmlinkage long sys_utime(char __user *filename, struct utimbuf __user *times) 26 { 27 struct timespec tv[2]; 28 29 if (times) { 30 if (get_user(tv[0].tv_sec, ×->actime) || 31 get_user(tv[1].tv_sec, ×->modtime)) 32 return -EFAULT; 33 tv[0].tv_nsec = 0; 34 tv[1].tv_nsec = 0; 35 } 36 return do_utimes(AT_FDCWD, filename, times ? tv : NULL, 0); 37 } 38 39 #endif 40 41 /* If times==NULL, set access and modification to current time, 42 * must be owner or have write permission. 43 * Else, update from *times, must be owner or super user. 44 */ 45 long do_utimes(int dfd, char __user *filename, struct timespec *times, int flags) 46 { 47 int error; 48 struct nameidata nd; 49 struct dentry *dentry; 50 struct inode *inode; 51 struct iattr newattrs; 52 struct file *f = NULL; 53 54 error = -EINVAL; 55 if (flags & ~AT_SYMLINK_NOFOLLOW) 56 goto out; 57 58 if (filename == NULL && dfd != AT_FDCWD) { 59 error = -EINVAL; 60 if (flags & AT_SYMLINK_NOFOLLOW) 61 goto out; 62 63 error = -EBADF; 64 f = fget(dfd); 65 if (!f) 66 goto out; 67 dentry = f->f_path.dentry; 68 } else { 69 error = __user_walk_fd(dfd, filename, (flags & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW, &nd); 70 if (error) 71 goto out; 72 73 dentry = nd.dentry; 74 } 75 76 inode = dentry->d_inode; 77 78 error = -EROFS; 79 if (IS_RDONLY(inode)) 80 goto dput_and_out; 81 82 /* Don't worry, the checks are done in inode_change_ok() */ 83 newattrs.ia_valid = ATTR_CTIME | ATTR_MTIME | ATTR_ATIME; 84 if (times) { 85 error = -EPERM; 86 if (IS_APPEND(inode) || IS_IMMUTABLE(inode)) 87 goto dput_and_out; 88 89 if (times[0].tv_nsec == UTIME_OMIT) 90 newattrs.ia_valid &= ~ATTR_ATIME; 91 else if (times[0].tv_nsec != UTIME_NOW) { 92 newattrs.ia_atime.tv_sec = times[0].tv_sec; 93 newattrs.ia_atime.tv_nsec = times[0].tv_nsec; 94 newattrs.ia_valid |= ATTR_ATIME_SET; 95 } 96 97 if (times[1].tv_nsec == UTIME_OMIT) 98 newattrs.ia_valid &= ~ATTR_MTIME; 99 else if (times[1].tv_nsec != UTIME_NOW) { 100 newattrs.ia_mtime.tv_sec = times[1].tv_sec; 101 newattrs.ia_mtime.tv_nsec = times[1].tv_nsec; 102 newattrs.ia_valid |= ATTR_MTIME_SET; 103 } 104 } else { 105 error = -EACCES; 106 if (IS_IMMUTABLE(inode)) 107 goto dput_and_out; 108 109 if (current->fsuid != inode->i_uid && 110 (error = vfs_permission(&nd, MAY_WRITE)) != 0) 111 goto dput_and_out; 112 } 113 mutex_lock(&inode->i_mutex); 114 error = notify_change(dentry, &newattrs); 115 mutex_unlock(&inode->i_mutex); 116 dput_and_out: 117 if (f) 118 fput(f); 119 else 120 path_release(&nd); 121 out: 122 return error; 123 } 124 125 asmlinkage long sys_utimensat(int dfd, char __user *filename, struct timespec __user *utimes, int flags) 126 { 127 struct timespec tstimes[2]; 128 129 if (utimes) { 130 if (copy_from_user(&tstimes, utimes, sizeof(tstimes))) 131 return -EFAULT; 132 if ((tstimes[0].tv_nsec == UTIME_OMIT || 133 tstimes[0].tv_nsec == UTIME_NOW) && 134 tstimes[0].tv_sec != 0) 135 return -EINVAL; 136 if ((tstimes[1].tv_nsec == UTIME_OMIT || 137 tstimes[1].tv_nsec == UTIME_NOW) && 138 tstimes[1].tv_sec != 0) 139 return -EINVAL; 140 141 /* Nothing to do, we must not even check the path. */ 142 if (tstimes[0].tv_nsec == UTIME_OMIT && 143 tstimes[1].tv_nsec == UTIME_OMIT) 144 return 0; 145 } 146 147 return do_utimes(dfd, filename, utimes ? tstimes : NULL, flags); 148 } 149 150 asmlinkage long sys_futimesat(int dfd, char __user *filename, struct timeval __user *utimes) 151 { 152 struct timeval times[2]; 153 struct timespec tstimes[2]; 154 155 if (utimes) { 156 if (copy_from_user(×, utimes, sizeof(times))) 157 return -EFAULT; 158 159 /* This test is needed to catch all invalid values. If we 160 would test only in do_utimes we would miss those invalid 161 values truncated by the multiplication with 1000. Note 162 that we also catch UTIME_{NOW,OMIT} here which are only 163 valid for utimensat. */ 164 if (times[0].tv_usec >= 1000000 || times[0].tv_usec < 0 || 165 times[1].tv_usec >= 1000000 || times[1].tv_usec < 0) 166 return -EINVAL; 167 168 tstimes[0].tv_sec = times[0].tv_sec; 169 tstimes[0].tv_nsec = 1000 * times[0].tv_usec; 170 tstimes[1].tv_sec = times[1].tv_sec; 171 tstimes[1].tv_nsec = 1000 * times[1].tv_usec; 172 } 173 174 return do_utimes(dfd, filename, utimes ? tstimes : NULL, 0); 175 } 176 177 asmlinkage long sys_utimes(char __user *filename, struct timeval __user *utimes) 178 { 179 return sys_futimesat(AT_FDCWD, filename, utimes); 180 } 181