aboutsummaryrefslogtreecommitdiffstats
path: root/fs/utimes.c
diff options
context:
space:
mode:
Diffstat (limited to 'fs/utimes.c')
-rw-r--r--fs/utimes.c162
1 files changed, 102 insertions, 60 deletions
diff --git a/fs/utimes.c b/fs/utimes.c
index 99cf2cb11fec..480f7c8c29da 100644
--- a/fs/utimes.c
+++ b/fs/utimes.c
@@ -1,8 +1,10 @@
1#include <linux/compiler.h> 1#include <linux/compiler.h>
2#include <linux/file.h>
2#include <linux/fs.h> 3#include <linux/fs.h>
3#include <linux/linkage.h> 4#include <linux/linkage.h>
4#include <linux/namei.h> 5#include <linux/namei.h>
5#include <linux/sched.h> 6#include <linux/sched.h>
7#include <linux/stat.h>
6#include <linux/utime.h> 8#include <linux/utime.h>
7#include <asm/uaccess.h> 9#include <asm/uaccess.h>
8#include <asm/unistd.h> 10#include <asm/unistd.h>
@@ -20,54 +22,18 @@
20 * must be owner or have write permission. 22 * must be owner or have write permission.
21 * Else, update from *times, must be owner or super user. 23 * Else, update from *times, must be owner or super user.
22 */ 24 */
23asmlinkage long sys_utime(char __user * filename, struct utimbuf __user * times) 25asmlinkage long sys_utime(char __user *filename, struct utimbuf __user *times)
24{ 26{
25 int error; 27 struct timespec tv[2];
26 struct nameidata nd;
27 struct inode * inode;
28 struct iattr newattrs;
29 28
30 error = user_path_walk(filename, &nd);
31 if (error)
32 goto out;
33 inode = nd.dentry->d_inode;
34
35 error = -EROFS;
36 if (IS_RDONLY(inode))
37 goto dput_and_out;
38
39 /* Don't worry, the checks are done in inode_change_ok() */
40 newattrs.ia_valid = ATTR_CTIME | ATTR_MTIME | ATTR_ATIME;
41 if (times) { 29 if (times) {
42 error = -EPERM; 30 if (get_user(tv[0].tv_sec, &times->actime) ||
43 if (IS_APPEND(inode) || IS_IMMUTABLE(inode)) 31 get_user(tv[1].tv_sec, &times->modtime))
44 goto dput_and_out; 32 return -EFAULT;
45 33 tv[0].tv_nsec = 0;
46 error = get_user(newattrs.ia_atime.tv_sec, &times->actime); 34 tv[1].tv_nsec = 0;
47 newattrs.ia_atime.tv_nsec = 0;
48 if (!error)
49 error = get_user(newattrs.ia_mtime.tv_sec, &times->modtime);
50 newattrs.ia_mtime.tv_nsec = 0;
51 if (error)
52 goto dput_and_out;
53
54 newattrs.ia_valid |= ATTR_ATIME_SET | ATTR_MTIME_SET;
55 } else {
56 error = -EACCES;
57 if (IS_IMMUTABLE(inode))
58 goto dput_and_out;
59
60 if (current->fsuid != inode->i_uid &&
61 (error = vfs_permission(&nd, MAY_WRITE)) != 0)
62 goto dput_and_out;
63 } 35 }
64 mutex_lock(&inode->i_mutex); 36 return do_utimes(AT_FDCWD, filename, times ? tv : NULL, 0);
65 error = notify_change(nd.dentry, &newattrs);
66 mutex_unlock(&inode->i_mutex);
67dput_and_out:
68 path_release(&nd);
69out:
70 return error;
71} 37}
72 38
73#endif 39#endif
@@ -76,18 +42,38 @@ out:
76 * must be owner or have write permission. 42 * must be owner or have write permission.
77 * Else, update from *times, must be owner or super user. 43 * Else, update from *times, must be owner or super user.
78 */ 44 */
79long do_utimes(int dfd, char __user *filename, struct timeval *times) 45long do_utimes(int dfd, char __user *filename, struct timespec *times, int flags)
80{ 46{
81 int error; 47 int error;
82 struct nameidata nd; 48 struct nameidata nd;
83 struct inode * inode; 49 struct dentry *dentry;
50 struct inode *inode;
84 struct iattr newattrs; 51 struct iattr newattrs;
52 struct file *f = NULL;
85 53
86 error = __user_walk_fd(dfd, filename, LOOKUP_FOLLOW, &nd); 54 error = -EINVAL;
87 55 if (flags & ~AT_SYMLINK_NOFOLLOW)
88 if (error)
89 goto out; 56 goto out;
90 inode = nd.dentry->d_inode; 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;
91 77
92 error = -EROFS; 78 error = -EROFS;
93 if (IS_RDONLY(inode)) 79 if (IS_RDONLY(inode))
@@ -100,11 +86,21 @@ long do_utimes(int dfd, char __user *filename, struct timeval *times)
100 if (IS_APPEND(inode) || IS_IMMUTABLE(inode)) 86 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
101 goto dput_and_out; 87 goto dput_and_out;
102 88
103 newattrs.ia_atime.tv_sec = times[0].tv_sec; 89 if (times[0].tv_nsec == UTIME_OMIT)
104 newattrs.ia_atime.tv_nsec = times[0].tv_usec * 1000; 90 newattrs.ia_valid &= ~ATTR_ATIME;
105 newattrs.ia_mtime.tv_sec = times[1].tv_sec; 91 else if (times[0].tv_nsec != UTIME_NOW) {
106 newattrs.ia_mtime.tv_nsec = times[1].tv_usec * 1000; 92 newattrs.ia_atime.tv_sec = times[0].tv_sec;
107 newattrs.ia_valid |= ATTR_ATIME_SET | ATTR_MTIME_SET; 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 }
108 } else { 104 } else {
109 error = -EACCES; 105 error = -EACCES;
110 if (IS_IMMUTABLE(inode)) 106 if (IS_IMMUTABLE(inode))
@@ -115,21 +111,67 @@ long do_utimes(int dfd, char __user *filename, struct timeval *times)
115 goto dput_and_out; 111 goto dput_and_out;
116 } 112 }
117 mutex_lock(&inode->i_mutex); 113 mutex_lock(&inode->i_mutex);
118 error = notify_change(nd.dentry, &newattrs); 114 error = notify_change(dentry, &newattrs);
119 mutex_unlock(&inode->i_mutex); 115 mutex_unlock(&inode->i_mutex);
120dput_and_out: 116dput_and_out:
121 path_release(&nd); 117 if (f)
118 fput(f);
119 else
120 path_release(&nd);
122out: 121out:
123 return error; 122 return error;
124} 123}
125 124
125asmlinkage 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
126asmlinkage long sys_futimesat(int dfd, char __user *filename, struct timeval __user *utimes) 150asmlinkage long sys_futimesat(int dfd, char __user *filename, struct timeval __user *utimes)
127{ 151{
128 struct timeval times[2]; 152 struct timeval times[2];
153 struct timespec tstimes[2];
154
155 if (utimes) {
156 if (copy_from_user(&times, 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 }
129 173
130 if (utimes && copy_from_user(&times, utimes, sizeof(times))) 174 return do_utimes(dfd, filename, utimes ? tstimes : NULL, 0);
131 return -EFAULT;
132 return do_utimes(dfd, filename, utimes ? times : NULL);
133} 175}
134 176
135asmlinkage long sys_utimes(char __user *filename, struct timeval __user *utimes) 177asmlinkage long sys_utimes(char __user *filename, struct timeval __user *utimes)
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-25 16:16:11 -0500