Root/
1 | #include <linux/compiler.h> |
2 | #include <linux/file.h> |
3 | #include <linux/fs.h> |
4 | #include <linux/linkage.h> |
5 | #include <linux/mount.h> |
6 | #include <linux/namei.h> |
7 | #include <linux/sched.h> |
8 | #include <linux/stat.h> |
9 | #include <linux/utime.h> |
10 | #include <linux/syscalls.h> |
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 | */ |
27 | SYSCALL_DEFINE2(utime, char __user *, filename, struct utimbuf __user *, times) |
28 | { |
29 | struct timespec tv[2]; |
30 | |
31 | if (times) { |
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; |
37 | } |
38 | return do_utimes(AT_FDCWD, filename, times ? tv : NULL, 0); |
39 | } |
40 | |
41 | #endif |
42 | |
43 | static bool nsec_valid(long nsec) |
44 | { |
45 | if (nsec == UTIME_OMIT || nsec == UTIME_NOW) |
46 | return true; |
47 | |
48 | return nsec >= 0 && nsec <= 999999999; |
49 | } |
50 | |
51 | static int utimes_common(struct path *path, struct timespec *times) |
52 | { |
53 | int error; |
54 | struct iattr newattrs; |
55 | struct inode *inode = path->dentry->d_inode; |
56 | struct inode *delegated_inode = NULL; |
57 | |
58 | error = mnt_want_write(path->mnt); |
59 | if (error) |
60 | goto out; |
61 | |
62 | if (times && times[0].tv_nsec == UTIME_NOW && |
63 | times[1].tv_nsec == UTIME_NOW) |
64 | times = NULL; |
65 | |
66 | newattrs.ia_valid = ATTR_CTIME | ATTR_MTIME | ATTR_ATIME; |
67 | if (times) { |
68 | if (times[0].tv_nsec == UTIME_OMIT) |
69 | newattrs.ia_valid &= ~ATTR_ATIME; |
70 | else if (times[0].tv_nsec != UTIME_NOW) { |
71 | newattrs.ia_atime.tv_sec = times[0].tv_sec; |
72 | newattrs.ia_atime.tv_nsec = times[0].tv_nsec; |
73 | newattrs.ia_valid |= ATTR_ATIME_SET; |
74 | } |
75 | |
76 | if (times[1].tv_nsec == UTIME_OMIT) |
77 | newattrs.ia_valid &= ~ATTR_MTIME; |
78 | else if (times[1].tv_nsec != UTIME_NOW) { |
79 | newattrs.ia_mtime.tv_sec = times[1].tv_sec; |
80 | newattrs.ia_mtime.tv_nsec = times[1].tv_nsec; |
81 | newattrs.ia_valid |= ATTR_MTIME_SET; |
82 | } |
83 | /* |
84 | * Tell inode_change_ok(), that this is an explicit time |
85 | * update, even if neither ATTR_ATIME_SET nor ATTR_MTIME_SET |
86 | * were used. |
87 | */ |
88 | newattrs.ia_valid |= ATTR_TIMES_SET; |
89 | } else { |
90 | /* |
91 | * If times is NULL (or both times are UTIME_NOW), |
92 | * then we need to check permissions, because |
93 | * inode_change_ok() won't do it. |
94 | */ |
95 | error = -EACCES; |
96 | if (IS_IMMUTABLE(inode)) |
97 | goto mnt_drop_write_and_out; |
98 | |
99 | if (!inode_owner_or_capable(inode)) { |
100 | error = inode_permission(inode, MAY_WRITE); |
101 | if (error) |
102 | goto mnt_drop_write_and_out; |
103 | } |
104 | } |
105 | retry_deleg: |
106 | mutex_lock(&inode->i_mutex); |
107 | error = notify_change(path->dentry, &newattrs, &delegated_inode); |
108 | mutex_unlock(&inode->i_mutex); |
109 | if (delegated_inode) { |
110 | error = break_deleg_wait(&delegated_inode); |
111 | if (!error) |
112 | goto retry_deleg; |
113 | } |
114 | |
115 | mnt_drop_write_and_out: |
116 | mnt_drop_write(path->mnt); |
117 | out: |
118 | return error; |
119 | } |
120 | |
121 | /* |
122 | * do_utimes - change times on filename or file descriptor |
123 | * @dfd: open file descriptor, -1 or AT_FDCWD |
124 | * @filename: path name or NULL |
125 | * @times: new times or NULL |
126 | * @flags: zero or more flags (only AT_SYMLINK_NOFOLLOW for the moment) |
127 | * |
128 | * If filename is NULL and dfd refers to an open file, then operate on |
129 | * the file. Otherwise look up filename, possibly using dfd as a |
130 | * starting point. |
131 | * |
132 | * If times==NULL, set access and modification to current time, |
133 | * must be owner or have write permission. |
134 | * Else, update from *times, must be owner or super user. |
135 | */ |
136 | long do_utimes(int dfd, const char __user *filename, struct timespec *times, |
137 | int flags) |
138 | { |
139 | int error = -EINVAL; |
140 | |
141 | if (times && (!nsec_valid(times[0].tv_nsec) || |
142 | !nsec_valid(times[1].tv_nsec))) { |
143 | goto out; |
144 | } |
145 | |
146 | if (flags & ~AT_SYMLINK_NOFOLLOW) |
147 | goto out; |
148 | |
149 | if (filename == NULL && dfd != AT_FDCWD) { |
150 | struct fd f; |
151 | |
152 | if (flags & AT_SYMLINK_NOFOLLOW) |
153 | goto out; |
154 | |
155 | f = fdget(dfd); |
156 | error = -EBADF; |
157 | if (!f.file) |
158 | goto out; |
159 | |
160 | error = utimes_common(&f.file->f_path, times); |
161 | fdput(f); |
162 | } else { |
163 | struct path path; |
164 | int lookup_flags = 0; |
165 | |
166 | if (!(flags & AT_SYMLINK_NOFOLLOW)) |
167 | lookup_flags |= LOOKUP_FOLLOW; |
168 | retry: |
169 | error = user_path_at(dfd, filename, lookup_flags, &path); |
170 | if (error) |
171 | goto out; |
172 | |
173 | error = utimes_common(&path, times); |
174 | path_put(&path); |
175 | if (retry_estale(error, lookup_flags)) { |
176 | lookup_flags |= LOOKUP_REVAL; |
177 | goto retry; |
178 | } |
179 | } |
180 | |
181 | out: |
182 | return error; |
183 | } |
184 | |
185 | SYSCALL_DEFINE4(utimensat, int, dfd, const char __user *, filename, |
186 | struct timespec __user *, utimes, int, flags) |
187 | { |
188 | struct timespec tstimes[2]; |
189 | |
190 | if (utimes) { |
191 | if (copy_from_user(&tstimes, utimes, sizeof(tstimes))) |
192 | return -EFAULT; |
193 | |
194 | /* Nothing to do, we must not even check the path. */ |
195 | if (tstimes[0].tv_nsec == UTIME_OMIT && |
196 | tstimes[1].tv_nsec == UTIME_OMIT) |
197 | return 0; |
198 | } |
199 | |
200 | return do_utimes(dfd, filename, utimes ? tstimes : NULL, flags); |
201 | } |
202 | |
203 | SYSCALL_DEFINE3(futimesat, int, dfd, const char __user *, filename, |
204 | struct timeval __user *, utimes) |
205 | { |
206 | struct timeval times[2]; |
207 | struct timespec tstimes[2]; |
208 | |
209 | if (utimes) { |
210 | if (copy_from_user(×, utimes, sizeof(times))) |
211 | return -EFAULT; |
212 | |
213 | /* This test is needed to catch all invalid values. If we |
214 | would test only in do_utimes we would miss those invalid |
215 | values truncated by the multiplication with 1000. Note |
216 | that we also catch UTIME_{NOW,OMIT} here which are only |
217 | valid for utimensat. */ |
218 | if (times[0].tv_usec >= 1000000 || times[0].tv_usec < 0 || |
219 | times[1].tv_usec >= 1000000 || times[1].tv_usec < 0) |
220 | return -EINVAL; |
221 | |
222 | tstimes[0].tv_sec = times[0].tv_sec; |
223 | tstimes[0].tv_nsec = 1000 * times[0].tv_usec; |
224 | tstimes[1].tv_sec = times[1].tv_sec; |
225 | tstimes[1].tv_nsec = 1000 * times[1].tv_usec; |
226 | } |
227 | |
228 | return do_utimes(dfd, filename, utimes ? tstimes : NULL, 0); |
229 | } |
230 | |
231 | SYSCALL_DEFINE2(utimes, char __user *, filename, |
232 | struct timeval __user *, utimes) |
233 | { |
234 | return sys_futimesat(AT_FDCWD, filename, utimes); |
235 | } |
236 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9