Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 1 | #include <linux/compiler.h> |
Ulrich Drepper | 1c710c8 | 2007-05-08 00:33:25 -0700 | [diff] [blame] | 2 | #include <linux/file.h> |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 3 | #include <linux/fs.h> |
| 4 | #include <linux/linkage.h> |
Dave Hansen | 74f9fdf | 2008-02-15 14:37:42 -0800 | [diff] [blame] | 5 | #include <linux/mount.h> |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 6 | #include <linux/namei.h> |
Al Viro | 914e263 | 2006-10-18 13:55:46 -0400 | [diff] [blame] | 7 | #include <linux/sched.h> |
Ulrich Drepper | 1c710c8 | 2007-05-08 00:33:25 -0700 | [diff] [blame] | 8 | #include <linux/stat.h> |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 9 | #include <linux/utime.h> |
Adrian Bunk | 12c2ab5 | 2008-02-06 01:36:47 -0800 | [diff] [blame] | 10 | #include <linux/syscalls.h> |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 11 | #include <asm/uaccess.h> |
| 12 | #include <asm/unistd.h> |
| 13 | |
| 14 | #ifdef __ARCH_WANT_SYS_UTIME |
| 15 | |
| 16 | /* |
| 17 | * sys_utime() can be implemented in user-level using sys_utimes(). |
| 18 | * Is this for backwards compatibility? If so, why not move it |
| 19 | * into the appropriate arch directory (for those architectures that |
| 20 | * need it). |
| 21 | */ |
| 22 | |
| 23 | /* If times==NULL, set access and modification to current time, |
| 24 | * must be owner or have write permission. |
| 25 | * Else, update from *times, must be owner or super user. |
| 26 | */ |
Ulrich Drepper | 1c710c8 | 2007-05-08 00:33:25 -0700 | [diff] [blame] | 27 | asmlinkage long sys_utime(char __user *filename, struct utimbuf __user *times) |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 28 | { |
Ulrich Drepper | 1c710c8 | 2007-05-08 00:33:25 -0700 | [diff] [blame] | 29 | struct timespec tv[2]; |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 30 | |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 31 | if (times) { |
Ulrich Drepper | 1c710c8 | 2007-05-08 00:33:25 -0700 | [diff] [blame] | 32 | if (get_user(tv[0].tv_sec, ×->actime) || |
| 33 | get_user(tv[1].tv_sec, ×->modtime)) |
| 34 | return -EFAULT; |
| 35 | tv[0].tv_nsec = 0; |
| 36 | tv[1].tv_nsec = 0; |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 37 | } |
Ulrich Drepper | 1c710c8 | 2007-05-08 00:33:25 -0700 | [diff] [blame] | 38 | return do_utimes(AT_FDCWD, filename, times ? tv : NULL, 0); |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 39 | } |
| 40 | |
| 41 | #endif |
| 42 | |
Miklos Szeredi | 02c6be6 | 2008-05-01 04:34:45 -0700 | [diff] [blame] | 43 | static bool nsec_special(long nsec) |
| 44 | { |
| 45 | return nsec == UTIME_OMIT || nsec == UTIME_NOW; |
| 46 | } |
| 47 | |
Miklos Szeredi | 043f46f | 2007-10-16 23:27:07 -0700 | [diff] [blame] | 48 | static bool nsec_valid(long nsec) |
| 49 | { |
Miklos Szeredi | 02c6be6 | 2008-05-01 04:34:45 -0700 | [diff] [blame] | 50 | if (nsec_special(nsec)) |
Miklos Szeredi | 043f46f | 2007-10-16 23:27:07 -0700 | [diff] [blame] | 51 | return true; |
| 52 | |
| 53 | return nsec >= 0 && nsec <= 999999999; |
| 54 | } |
| 55 | |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 56 | /* If times==NULL, set access and modification to current time, |
| 57 | * must be owner or have write permission. |
| 58 | * Else, update from *times, must be owner or super user. |
| 59 | */ |
Ulrich Drepper | 1c710c8 | 2007-05-08 00:33:25 -0700 | [diff] [blame] | 60 | long do_utimes(int dfd, char __user *filename, struct timespec *times, int flags) |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 61 | { |
| 62 | int error; |
| 63 | struct nameidata nd; |
Ulrich Drepper | 1c710c8 | 2007-05-08 00:33:25 -0700 | [diff] [blame] | 64 | struct dentry *dentry; |
| 65 | struct inode *inode; |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 66 | struct iattr newattrs; |
Ulrich Drepper | 1c710c8 | 2007-05-08 00:33:25 -0700 | [diff] [blame] | 67 | struct file *f = NULL; |
Dave Hansen | 74f9fdf | 2008-02-15 14:37:42 -0800 | [diff] [blame] | 68 | struct vfsmount *mnt; |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 69 | |
Ulrich Drepper | 1c710c8 | 2007-05-08 00:33:25 -0700 | [diff] [blame] | 70 | error = -EINVAL; |
Miklos Szeredi | 043f46f | 2007-10-16 23:27:07 -0700 | [diff] [blame] | 71 | if (times && (!nsec_valid(times[0].tv_nsec) || |
| 72 | !nsec_valid(times[1].tv_nsec))) { |
| 73 | goto out; |
| 74 | } |
| 75 | |
Ulrich Drepper | 1c710c8 | 2007-05-08 00:33:25 -0700 | [diff] [blame] | 76 | if (flags & ~AT_SYMLINK_NOFOLLOW) |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 77 | goto out; |
Ulrich Drepper | 1c710c8 | 2007-05-08 00:33:25 -0700 | [diff] [blame] | 78 | |
| 79 | if (filename == NULL && dfd != AT_FDCWD) { |
| 80 | error = -EINVAL; |
| 81 | if (flags & AT_SYMLINK_NOFOLLOW) |
| 82 | goto out; |
| 83 | |
| 84 | error = -EBADF; |
| 85 | f = fget(dfd); |
| 86 | if (!f) |
| 87 | goto out; |
| 88 | dentry = f->f_path.dentry; |
Dave Hansen | 74f9fdf | 2008-02-15 14:37:42 -0800 | [diff] [blame] | 89 | mnt = f->f_path.mnt; |
Ulrich Drepper | 1c710c8 | 2007-05-08 00:33:25 -0700 | [diff] [blame] | 90 | } else { |
| 91 | error = __user_walk_fd(dfd, filename, (flags & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW, &nd); |
| 92 | if (error) |
| 93 | goto out; |
| 94 | |
Jan Blunck | 4ac9137 | 2008-02-14 19:34:32 -0800 | [diff] [blame] | 95 | dentry = nd.path.dentry; |
Dave Hansen | 74f9fdf | 2008-02-15 14:37:42 -0800 | [diff] [blame] | 96 | mnt = nd.path.mnt; |
Ulrich Drepper | 1c710c8 | 2007-05-08 00:33:25 -0700 | [diff] [blame] | 97 | } |
| 98 | |
| 99 | inode = dentry->d_inode; |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 100 | |
Dave Hansen | 74f9fdf | 2008-02-15 14:37:42 -0800 | [diff] [blame] | 101 | error = mnt_want_write(mnt); |
| 102 | if (error) |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 103 | goto dput_and_out; |
| 104 | |
| 105 | /* Don't worry, the checks are done in inode_change_ok() */ |
| 106 | newattrs.ia_valid = ATTR_CTIME | ATTR_MTIME | ATTR_ATIME; |
| 107 | if (times) { |
| 108 | error = -EPERM; |
| 109 | if (IS_APPEND(inode) || IS_IMMUTABLE(inode)) |
Dave Hansen | 74f9fdf | 2008-02-15 14:37:42 -0800 | [diff] [blame] | 110 | goto mnt_drop_write_and_out; |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 111 | |
Ulrich Drepper | 1c710c8 | 2007-05-08 00:33:25 -0700 | [diff] [blame] | 112 | if (times[0].tv_nsec == UTIME_OMIT) |
| 113 | newattrs.ia_valid &= ~ATTR_ATIME; |
| 114 | else if (times[0].tv_nsec != UTIME_NOW) { |
| 115 | newattrs.ia_atime.tv_sec = times[0].tv_sec; |
| 116 | newattrs.ia_atime.tv_nsec = times[0].tv_nsec; |
| 117 | newattrs.ia_valid |= ATTR_ATIME_SET; |
| 118 | } |
| 119 | |
| 120 | if (times[1].tv_nsec == UTIME_OMIT) |
| 121 | newattrs.ia_valid &= ~ATTR_MTIME; |
| 122 | else if (times[1].tv_nsec != UTIME_NOW) { |
| 123 | newattrs.ia_mtime.tv_sec = times[1].tv_sec; |
| 124 | newattrs.ia_mtime.tv_nsec = times[1].tv_nsec; |
| 125 | newattrs.ia_valid |= ATTR_MTIME_SET; |
| 126 | } |
Miklos Szeredi | 02c6be6 | 2008-05-01 04:34:45 -0700 | [diff] [blame] | 127 | } |
| 128 | |
| 129 | /* |
| 130 | * If times is NULL or both times are either UTIME_OMIT or |
| 131 | * UTIME_NOW, then need to check permissions, because |
| 132 | * inode_change_ok() won't do it. |
| 133 | */ |
| 134 | if (!times || (nsec_special(times[0].tv_nsec) && |
| 135 | nsec_special(times[1].tv_nsec))) { |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 136 | error = -EACCES; |
| 137 | if (IS_IMMUTABLE(inode)) |
Dave Hansen | 74f9fdf | 2008-02-15 14:37:42 -0800 | [diff] [blame] | 138 | goto mnt_drop_write_and_out; |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 139 | |
Satyam Sharma | 3bd858a | 2007-07-17 15:00:08 +0530 | [diff] [blame] | 140 | if (!is_owner_or_cap(inode)) { |
Linus Torvalds | 1e5de28 | 2007-07-08 12:02:55 -0700 | [diff] [blame] | 141 | if (f) { |
| 142 | if (!(f->f_mode & FMODE_WRITE)) |
Dave Hansen | 74f9fdf | 2008-02-15 14:37:42 -0800 | [diff] [blame] | 143 | goto mnt_drop_write_and_out; |
Linus Torvalds | 1e5de28 | 2007-07-08 12:02:55 -0700 | [diff] [blame] | 144 | } else { |
| 145 | error = vfs_permission(&nd, MAY_WRITE); |
| 146 | if (error) |
Dave Hansen | 74f9fdf | 2008-02-15 14:37:42 -0800 | [diff] [blame] | 147 | goto mnt_drop_write_and_out; |
Linus Torvalds | 1e5de28 | 2007-07-08 12:02:55 -0700 | [diff] [blame] | 148 | } |
| 149 | } |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 150 | } |
| 151 | mutex_lock(&inode->i_mutex); |
Ulrich Drepper | 1c710c8 | 2007-05-08 00:33:25 -0700 | [diff] [blame] | 152 | error = notify_change(dentry, &newattrs); |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 153 | mutex_unlock(&inode->i_mutex); |
Dave Hansen | 74f9fdf | 2008-02-15 14:37:42 -0800 | [diff] [blame] | 154 | mnt_drop_write_and_out: |
| 155 | mnt_drop_write(mnt); |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 156 | dput_and_out: |
Ulrich Drepper | 1c710c8 | 2007-05-08 00:33:25 -0700 | [diff] [blame] | 157 | if (f) |
| 158 | fput(f); |
| 159 | else |
Jan Blunck | 1d957f9 | 2008-02-14 19:34:35 -0800 | [diff] [blame] | 160 | path_put(&nd.path); |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 161 | out: |
| 162 | return error; |
| 163 | } |
| 164 | |
Ulrich Drepper | 1c710c8 | 2007-05-08 00:33:25 -0700 | [diff] [blame] | 165 | asmlinkage long sys_utimensat(int dfd, char __user *filename, struct timespec __user *utimes, int flags) |
| 166 | { |
| 167 | struct timespec tstimes[2]; |
| 168 | |
| 169 | if (utimes) { |
| 170 | if (copy_from_user(&tstimes, utimes, sizeof(tstimes))) |
| 171 | return -EFAULT; |
| 172 | if ((tstimes[0].tv_nsec == UTIME_OMIT || |
| 173 | tstimes[0].tv_nsec == UTIME_NOW) && |
| 174 | tstimes[0].tv_sec != 0) |
| 175 | return -EINVAL; |
| 176 | if ((tstimes[1].tv_nsec == UTIME_OMIT || |
| 177 | tstimes[1].tv_nsec == UTIME_NOW) && |
| 178 | tstimes[1].tv_sec != 0) |
| 179 | return -EINVAL; |
| 180 | |
| 181 | /* Nothing to do, we must not even check the path. */ |
| 182 | if (tstimes[0].tv_nsec == UTIME_OMIT && |
| 183 | tstimes[1].tv_nsec == UTIME_OMIT) |
| 184 | return 0; |
| 185 | } |
| 186 | |
| 187 | return do_utimes(dfd, filename, utimes ? tstimes : NULL, flags); |
| 188 | } |
| 189 | |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 190 | asmlinkage long sys_futimesat(int dfd, char __user *filename, struct timeval __user *utimes) |
| 191 | { |
| 192 | struct timeval times[2]; |
Ulrich Drepper | 1c710c8 | 2007-05-08 00:33:25 -0700 | [diff] [blame] | 193 | struct timespec tstimes[2]; |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 194 | |
Ulrich Drepper | 1c710c8 | 2007-05-08 00:33:25 -0700 | [diff] [blame] | 195 | if (utimes) { |
| 196 | if (copy_from_user(×, utimes, sizeof(times))) |
| 197 | return -EFAULT; |
| 198 | |
| 199 | /* This test is needed to catch all invalid values. If we |
| 200 | would test only in do_utimes we would miss those invalid |
| 201 | values truncated by the multiplication with 1000. Note |
| 202 | that we also catch UTIME_{NOW,OMIT} here which are only |
| 203 | valid for utimensat. */ |
| 204 | if (times[0].tv_usec >= 1000000 || times[0].tv_usec < 0 || |
| 205 | times[1].tv_usec >= 1000000 || times[1].tv_usec < 0) |
| 206 | return -EINVAL; |
| 207 | |
| 208 | tstimes[0].tv_sec = times[0].tv_sec; |
| 209 | tstimes[0].tv_nsec = 1000 * times[0].tv_usec; |
| 210 | tstimes[1].tv_sec = times[1].tv_sec; |
| 211 | tstimes[1].tv_nsec = 1000 * times[1].tv_usec; |
| 212 | } |
| 213 | |
| 214 | return do_utimes(dfd, filename, utimes ? tstimes : NULL, 0); |
Alexey Dobriyan | 82b0547 | 2006-09-30 23:27:22 -0700 | [diff] [blame] | 215 | } |
| 216 | |
| 217 | asmlinkage long sys_utimes(char __user *filename, struct timeval __user *utimes) |
| 218 | { |
| 219 | return sys_futimesat(AT_FDCWD, filename, utimes); |
| 220 | } |