1 #include <linux/compiler.h>
2 #include <linux/file.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>
14 #ifdef __ARCH_WANT_SYS_UTIME
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
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.
27 asmlinkage
long sys_utime(char __user
*filename
, struct utimbuf __user
*times
)
29 struct timespec tv
[2];
32 if (get_user(tv
[0].tv_sec
, ×
->actime
) ||
33 get_user(tv
[1].tv_sec
, ×
->modtime
))
38 return do_utimes(AT_FDCWD
, filename
, times
? tv
: NULL
, 0);
43 static bool nsec_valid(long nsec
)
45 if (nsec
== UTIME_OMIT
|| nsec
== UTIME_NOW
)
48 return nsec
>= 0 && nsec
<= 999999999;
51 /* If times==NULL, set access and modification to current time,
52 * must be owner or have write permission.
53 * Else, update from *times, must be owner or super user.
55 long do_utimes(int dfd
, char __user
*filename
, struct timespec
*times
, int flags
)
59 struct dentry
*dentry
;
61 struct iattr newattrs
;
62 struct file
*f
= NULL
;
66 if (times
&& (!nsec_valid(times
[0].tv_nsec
) ||
67 !nsec_valid(times
[1].tv_nsec
))) {
71 if (flags
& ~AT_SYMLINK_NOFOLLOW
)
74 if (filename
== NULL
&& dfd
!= AT_FDCWD
) {
76 if (flags
& AT_SYMLINK_NOFOLLOW
)
83 dentry
= f
->f_path
.dentry
;
86 error
= __user_walk_fd(dfd
, filename
, (flags
& AT_SYMLINK_NOFOLLOW
) ? 0 : LOOKUP_FOLLOW
, &nd
);
90 dentry
= nd
.path
.dentry
;
94 inode
= dentry
->d_inode
;
96 error
= mnt_want_write(mnt
);
100 if (times
&& times
[0].tv_nsec
== UTIME_NOW
&&
101 times
[1].tv_nsec
== UTIME_NOW
)
104 /* In most cases, the checks are done in inode_change_ok() */
105 newattrs
.ia_valid
= ATTR_CTIME
| ATTR_MTIME
| ATTR_ATIME
;
108 if (IS_APPEND(inode
) || IS_IMMUTABLE(inode
))
109 goto mnt_drop_write_and_out
;
111 if (times
[0].tv_nsec
== UTIME_OMIT
)
112 newattrs
.ia_valid
&= ~ATTR_ATIME
;
113 else if (times
[0].tv_nsec
!= UTIME_NOW
) {
114 newattrs
.ia_atime
.tv_sec
= times
[0].tv_sec
;
115 newattrs
.ia_atime
.tv_nsec
= times
[0].tv_nsec
;
116 newattrs
.ia_valid
|= ATTR_ATIME_SET
;
119 if (times
[1].tv_nsec
== UTIME_OMIT
)
120 newattrs
.ia_valid
&= ~ATTR_MTIME
;
121 else if (times
[1].tv_nsec
!= UTIME_NOW
) {
122 newattrs
.ia_mtime
.tv_sec
= times
[1].tv_sec
;
123 newattrs
.ia_mtime
.tv_nsec
= times
[1].tv_nsec
;
124 newattrs
.ia_valid
|= ATTR_MTIME_SET
;
128 * For the UTIME_OMIT/UTIME_NOW and UTIME_NOW/UTIME_OMIT
129 * cases, we need to make an extra check that is not done by
132 if (((times
[0].tv_nsec
== UTIME_NOW
&&
133 times
[1].tv_nsec
== UTIME_OMIT
)
135 (times
[0].tv_nsec
== UTIME_OMIT
&&
136 times
[1].tv_nsec
== UTIME_NOW
))
137 && !is_owner_or_cap(inode
))
138 goto mnt_drop_write_and_out
;
142 * If times is NULL (or both times are UTIME_NOW),
143 * then we need to check permissions, because
144 * inode_change_ok() won't do it.
147 if (IS_IMMUTABLE(inode
))
148 goto mnt_drop_write_and_out
;
150 if (!is_owner_or_cap(inode
)) {
151 error
= permission(inode
, MAY_WRITE
, NULL
);
153 goto mnt_drop_write_and_out
;
156 mutex_lock(&inode
->i_mutex
);
157 error
= notify_change(dentry
, &newattrs
);
158 mutex_unlock(&inode
->i_mutex
);
159 mnt_drop_write_and_out
:
170 asmlinkage
long sys_utimensat(int dfd
, char __user
*filename
, struct timespec __user
*utimes
, int flags
)
172 struct timespec tstimes
[2];
175 if (copy_from_user(&tstimes
, utimes
, sizeof(tstimes
)))
178 /* Nothing to do, we must not even check the path. */
179 if (tstimes
[0].tv_nsec
== UTIME_OMIT
&&
180 tstimes
[1].tv_nsec
== UTIME_OMIT
)
184 return do_utimes(dfd
, filename
, utimes
? tstimes
: NULL
, flags
);
187 asmlinkage
long sys_futimesat(int dfd
, char __user
*filename
, struct timeval __user
*utimes
)
189 struct timeval times
[2];
190 struct timespec tstimes
[2];
193 if (copy_from_user(×
, utimes
, sizeof(times
)))
196 /* This test is needed to catch all invalid values. If we
197 would test only in do_utimes we would miss those invalid
198 values truncated by the multiplication with 1000. Note
199 that we also catch UTIME_{NOW,OMIT} here which are only
200 valid for utimensat. */
201 if (times
[0].tv_usec
>= 1000000 || times
[0].tv_usec
< 0 ||
202 times
[1].tv_usec
>= 1000000 || times
[1].tv_usec
< 0)
205 tstimes
[0].tv_sec
= times
[0].tv_sec
;
206 tstimes
[0].tv_nsec
= 1000 * times
[0].tv_usec
;
207 tstimes
[1].tv_sec
= times
[1].tv_sec
;
208 tstimes
[1].tv_nsec
= 1000 * times
[1].tv_usec
;
211 return do_utimes(dfd
, filename
, utimes
? tstimes
: NULL
, 0);
214 asmlinkage
long sys_utimes(char __user
*filename
, struct timeval __user
*utimes
)
216 return sys_futimesat(AT_FDCWD
, filename
, utimes
);
This page took 0.034871 seconds and 5 git commands to generate.