Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 4cf27141cbe0239f48ec6f0b37bad347d51d1785

Authored by Al Viro
1 parent 43e15cdbef
Exists in master and in 6 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

make exec_permission(dir) really equivalent to inode_permission(dir, MAY_EXEC) 

capability overrides apply only to the default case; if fs has ->permission()
that does _not_ call generic_permission(), we have no business doing them.
Moreover, if it has ->permission() that does call generic_permission(), we
have no need to recheck capabilities.

Besides, the capability overrides should apply only if we got EACCES from
acl_permission_check(); any other value (-EIO, etc.) should be returned
to caller, capabilities or not capabilities.

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

Showing 1 changed file with 9 additions and 9 deletions Inline Diff

1 /* 1 /*
2 * linux/fs/namei.c 2 * linux/fs/namei.c
3 * 3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds 4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */ 5 */
6 6
7 /* 7 /*
8 * Some corrections by tytso. 8 * Some corrections by tytso.
9 */ 9 */
10 10
11 /* [Feb 1997 T. Schoebel-Theuer] Complete rewrite of the pathname 11 /* [Feb 1997 T. Schoebel-Theuer] Complete rewrite of the pathname
12 * lookup logic. 12 * lookup logic.
13 */ 13 */
14 /* [Feb-Apr 2000, AV] Rewrite to the new namespace architecture. 14 /* [Feb-Apr 2000, AV] Rewrite to the new namespace architecture.
15 */ 15 */
16 16
17 #include <linux/init.h> 17 #include <linux/init.h>
18 #include <linux/module.h> 18 #include <linux/module.h>
19 #include <linux/slab.h> 19 #include <linux/slab.h>
20 #include <linux/fs.h> 20 #include <linux/fs.h>
21 #include <linux/namei.h> 21 #include <linux/namei.h>
22 #include <linux/pagemap.h> 22 #include <linux/pagemap.h>
23 #include <linux/fsnotify.h> 23 #include <linux/fsnotify.h>
24 #include <linux/personality.h> 24 #include <linux/personality.h>
25 #include <linux/security.h> 25 #include <linux/security.h>
26 #include <linux/ima.h> 26 #include <linux/ima.h>
27 #include <linux/syscalls.h> 27 #include <linux/syscalls.h>
28 #include <linux/mount.h> 28 #include <linux/mount.h>
29 #include <linux/audit.h> 29 #include <linux/audit.h>
30 #include <linux/capability.h> 30 #include <linux/capability.h>
31 #include <linux/file.h> 31 #include <linux/file.h>
32 #include <linux/fcntl.h> 32 #include <linux/fcntl.h>
33 #include <linux/device_cgroup.h> 33 #include <linux/device_cgroup.h>
34 #include <linux/fs_struct.h> 34 #include <linux/fs_struct.h>
35 #include <asm/uaccess.h> 35 #include <asm/uaccess.h>
36 36
37 #include "internal.h" 37 #include "internal.h"
38 38
39 /* [Feb-1997 T. Schoebel-Theuer] 39 /* [Feb-1997 T. Schoebel-Theuer]
40 * Fundamental changes in the pathname lookup mechanisms (namei) 40 * Fundamental changes in the pathname lookup mechanisms (namei)
41 * were necessary because of omirr. The reason is that omirr needs 41 * were necessary because of omirr. The reason is that omirr needs
42 * to know the _real_ pathname, not the user-supplied one, in case 42 * to know the _real_ pathname, not the user-supplied one, in case
43 * of symlinks (and also when transname replacements occur). 43 * of symlinks (and also when transname replacements occur).
44 * 44 *
45 * The new code replaces the old recursive symlink resolution with 45 * The new code replaces the old recursive symlink resolution with
46 * an iterative one (in case of non-nested symlink chains). It does 46 * an iterative one (in case of non-nested symlink chains). It does
47 * this with calls to <fs>_follow_link(). 47 * this with calls to <fs>_follow_link().
48 * As a side effect, dir_namei(), _namei() and follow_link() are now 48 * As a side effect, dir_namei(), _namei() and follow_link() are now
49 * replaced with a single function lookup_dentry() that can handle all 49 * replaced with a single function lookup_dentry() that can handle all
50 * the special cases of the former code. 50 * the special cases of the former code.
51 * 51 *
52 * With the new dcache, the pathname is stored at each inode, at least as 52 * With the new dcache, the pathname is stored at each inode, at least as
53 * long as the refcount of the inode is positive. As a side effect, the 53 * long as the refcount of the inode is positive. As a side effect, the
54 * size of the dcache depends on the inode cache and thus is dynamic. 54 * size of the dcache depends on the inode cache and thus is dynamic.
55 * 55 *
56 * [29-Apr-1998 C. Scott Ananian] Updated above description of symlink 56 * [29-Apr-1998 C. Scott Ananian] Updated above description of symlink
57 * resolution to correspond with current state of the code. 57 * resolution to correspond with current state of the code.
58 * 58 *
59 * Note that the symlink resolution is not *completely* iterative. 59 * Note that the symlink resolution is not *completely* iterative.
60 * There is still a significant amount of tail- and mid- recursion in 60 * There is still a significant amount of tail- and mid- recursion in
61 * the algorithm. Also, note that <fs>_readlink() is not used in 61 * the algorithm. Also, note that <fs>_readlink() is not used in
62 * lookup_dentry(): lookup_dentry() on the result of <fs>_readlink() 62 * lookup_dentry(): lookup_dentry() on the result of <fs>_readlink()
63 * may return different results than <fs>_follow_link(). Many virtual 63 * may return different results than <fs>_follow_link(). Many virtual
64 * filesystems (including /proc) exhibit this behavior. 64 * filesystems (including /proc) exhibit this behavior.
65 */ 65 */
66 66
67 /* [24-Feb-97 T. Schoebel-Theuer] Side effects caused by new implementation: 67 /* [24-Feb-97 T. Schoebel-Theuer] Side effects caused by new implementation:
68 * New symlink semantics: when open() is called with flags O_CREAT | O_EXCL 68 * New symlink semantics: when open() is called with flags O_CREAT | O_EXCL
69 * and the name already exists in form of a symlink, try to create the new 69 * and the name already exists in form of a symlink, try to create the new
70 * name indicated by the symlink. The old code always complained that the 70 * name indicated by the symlink. The old code always complained that the
71 * name already exists, due to not following the symlink even if its target 71 * name already exists, due to not following the symlink even if its target
72 * is nonexistent. The new semantics affects also mknod() and link() when 72 * is nonexistent. The new semantics affects also mknod() and link() when
73 * the name is a symlink pointing to a non-existent name. 73 * the name is a symlink pointing to a non-existent name.
74 * 74 *
75 * I don't know which semantics is the right one, since I have no access 75 * I don't know which semantics is the right one, since I have no access
76 * to standards. But I found by trial that HP-UX 9.0 has the full "new" 76 * to standards. But I found by trial that HP-UX 9.0 has the full "new"
77 * semantics implemented, while SunOS 4.1.1 and Solaris (SunOS 5.4) have the 77 * semantics implemented, while SunOS 4.1.1 and Solaris (SunOS 5.4) have the
78 * "old" one. Personally, I think the new semantics is much more logical. 78 * "old" one. Personally, I think the new semantics is much more logical.
79 * Note that "ln old new" where "new" is a symlink pointing to a non-existing 79 * Note that "ln old new" where "new" is a symlink pointing to a non-existing
80 * file does succeed in both HP-UX and SunOs, but not in Solaris 80 * file does succeed in both HP-UX and SunOs, but not in Solaris
81 * and in the old Linux semantics. 81 * and in the old Linux semantics.
82 */ 82 */
83 83
84 /* [16-Dec-97 Kevin Buhr] For security reasons, we change some symlink 84 /* [16-Dec-97 Kevin Buhr] For security reasons, we change some symlink
85 * semantics. See the comments in "open_namei" and "do_link" below. 85 * semantics. See the comments in "open_namei" and "do_link" below.
86 * 86 *
87 * [10-Sep-98 Alan Modra] Another symlink change. 87 * [10-Sep-98 Alan Modra] Another symlink change.
88 */ 88 */
89 89
90 /* [Feb-Apr 2000 AV] Complete rewrite. Rules for symlinks: 90 /* [Feb-Apr 2000 AV] Complete rewrite. Rules for symlinks:
91 * inside the path - always follow. 91 * inside the path - always follow.
92 * in the last component in creation/removal/renaming - never follow. 92 * in the last component in creation/removal/renaming - never follow.
93 * if LOOKUP_FOLLOW passed - follow. 93 * if LOOKUP_FOLLOW passed - follow.
94 * if the pathname has trailing slashes - follow. 94 * if the pathname has trailing slashes - follow.
95 * otherwise - don't follow. 95 * otherwise - don't follow.
96 * (applied in that order). 96 * (applied in that order).
97 * 97 *
98 * [Jun 2000 AV] Inconsistent behaviour of open() in case if flags==O_CREAT 98 * [Jun 2000 AV] Inconsistent behaviour of open() in case if flags==O_CREAT
99 * restored for 2.4. This is the last surviving part of old 4.2BSD bug. 99 * restored for 2.4. This is the last surviving part of old 4.2BSD bug.
100 * During the 2.4 we need to fix the userland stuff depending on it - 100 * During the 2.4 we need to fix the userland stuff depending on it -
101 * hopefully we will be able to get rid of that wart in 2.5. So far only 101 * hopefully we will be able to get rid of that wart in 2.5. So far only
102 * XEmacs seems to be relying on it... 102 * XEmacs seems to be relying on it...
103 */ 103 */
104 /* 104 /*
105 * [Sep 2001 AV] Single-semaphore locking scheme (kudos to David Holland) 105 * [Sep 2001 AV] Single-semaphore locking scheme (kudos to David Holland)
106 * implemented. Let's see if raised priority of ->s_vfs_rename_mutex gives 106 * implemented. Let's see if raised priority of ->s_vfs_rename_mutex gives
107 * any extra contention... 107 * any extra contention...
108 */ 108 */
109 109
110 /* In order to reduce some races, while at the same time doing additional 110 /* In order to reduce some races, while at the same time doing additional
111 * checking and hopefully speeding things up, we copy filenames to the 111 * checking and hopefully speeding things up, we copy filenames to the
112 * kernel data space before using them.. 112 * kernel data space before using them..
113 * 113 *
114 * POSIX.1 2.4: an empty pathname is invalid (ENOENT). 114 * POSIX.1 2.4: an empty pathname is invalid (ENOENT).
115 * PATH_MAX includes the nul terminator --RR. 115 * PATH_MAX includes the nul terminator --RR.
116 */ 116 */
117 static int do_getname(const char __user *filename, char *page) 117 static int do_getname(const char __user *filename, char *page)
118 { 118 {
119 int retval; 119 int retval;
120 unsigned long len = PATH_MAX; 120 unsigned long len = PATH_MAX;
121 121
122 if (!segment_eq(get_fs(), KERNEL_DS)) { 122 if (!segment_eq(get_fs(), KERNEL_DS)) {
123 if ((unsigned long) filename >= TASK_SIZE) 123 if ((unsigned long) filename >= TASK_SIZE)
124 return -EFAULT; 124 return -EFAULT;
125 if (TASK_SIZE - (unsigned long) filename < PATH_MAX) 125 if (TASK_SIZE - (unsigned long) filename < PATH_MAX)
126 len = TASK_SIZE - (unsigned long) filename; 126 len = TASK_SIZE - (unsigned long) filename;
127 } 127 }
128 128
129 retval = strncpy_from_user(page, filename, len); 129 retval = strncpy_from_user(page, filename, len);
130 if (retval > 0) { 130 if (retval > 0) {
131 if (retval < len) 131 if (retval < len)
132 return 0; 132 return 0;
133 return -ENAMETOOLONG; 133 return -ENAMETOOLONG;
134 } else if (!retval) 134 } else if (!retval)
135 retval = -ENOENT; 135 retval = -ENOENT;
136 return retval; 136 return retval;
137 } 137 }
138 138
139 static char *getname_flags(const char __user * filename, int flags) 139 static char *getname_flags(const char __user * filename, int flags)
140 { 140 {
141 char *tmp, *result; 141 char *tmp, *result;
142 142
143 result = ERR_PTR(-ENOMEM); 143 result = ERR_PTR(-ENOMEM);
144 tmp = __getname(); 144 tmp = __getname();
145 if (tmp) { 145 if (tmp) {
146 int retval = do_getname(filename, tmp); 146 int retval = do_getname(filename, tmp);
147 147
148 result = tmp; 148 result = tmp;
149 if (retval < 0) { 149 if (retval < 0) {
150 if (retval != -ENOENT || !(flags & LOOKUP_EMPTY)) { 150 if (retval != -ENOENT || !(flags & LOOKUP_EMPTY)) {
151 __putname(tmp); 151 __putname(tmp);
152 result = ERR_PTR(retval); 152 result = ERR_PTR(retval);
153 } 153 }
154 } 154 }
155 } 155 }
156 audit_getname(result); 156 audit_getname(result);
157 return result; 157 return result;
158 } 158 }
159 159
160 char *getname(const char __user * filename) 160 char *getname(const char __user * filename)
161 { 161 {
162 return getname_flags(filename, 0); 162 return getname_flags(filename, 0);
163 } 163 }
164 164
165 #ifdef CONFIG_AUDITSYSCALL 165 #ifdef CONFIG_AUDITSYSCALL
166 void putname(const char *name) 166 void putname(const char *name)
167 { 167 {
168 if (unlikely(!audit_dummy_context())) 168 if (unlikely(!audit_dummy_context()))
169 audit_putname(name); 169 audit_putname(name);
170 else 170 else
171 __putname(name); 171 __putname(name);
172 } 172 }
173 EXPORT_SYMBOL(putname); 173 EXPORT_SYMBOL(putname);
174 #endif 174 #endif
175 175
176 /* 176 /*
177 * This does basic POSIX ACL permission checking 177 * This does basic POSIX ACL permission checking
178 */ 178 */
179 static int acl_permission_check(struct inode *inode, int mask, unsigned int flags, 179 static int acl_permission_check(struct inode *inode, int mask, unsigned int flags,
180 int (*check_acl)(struct inode *inode, int mask, unsigned int flags)) 180 int (*check_acl)(struct inode *inode, int mask, unsigned int flags))
181 { 181 {
182 unsigned int mode = inode->i_mode; 182 unsigned int mode = inode->i_mode;
183 183
184 mask &= MAY_READ | MAY_WRITE | MAY_EXEC; 184 mask &= MAY_READ | MAY_WRITE | MAY_EXEC;
185 185
186 if (current_user_ns() != inode_userns(inode)) 186 if (current_user_ns() != inode_userns(inode))
187 goto other_perms; 187 goto other_perms;
188 188
189 if (current_fsuid() == inode->i_uid) 189 if (current_fsuid() == inode->i_uid)
190 mode >>= 6; 190 mode >>= 6;
191 else { 191 else {
192 if (IS_POSIXACL(inode) && (mode & S_IRWXG) && check_acl) { 192 if (IS_POSIXACL(inode) && (mode & S_IRWXG) && check_acl) {
193 int error = check_acl(inode, mask, flags); 193 int error = check_acl(inode, mask, flags);
194 if (error != -EAGAIN) 194 if (error != -EAGAIN)
195 return error; 195 return error;
196 } 196 }
197 197
198 if (in_group_p(inode->i_gid)) 198 if (in_group_p(inode->i_gid))
199 mode >>= 3; 199 mode >>= 3;
200 } 200 }
201 201
202 other_perms: 202 other_perms:
203 /* 203 /*
204 * If the DACs are ok we don't need any capability check. 204 * If the DACs are ok we don't need any capability check.
205 */ 205 */
206 if ((mask & ~mode) == 0) 206 if ((mask & ~mode) == 0)
207 return 0; 207 return 0;
208 return -EACCES; 208 return -EACCES;
209 } 209 }
210 210
211 /** 211 /**
212 * generic_permission - check for access rights on a Posix-like filesystem 212 * generic_permission - check for access rights on a Posix-like filesystem
213 * @inode: inode to check access rights for 213 * @inode: inode to check access rights for
214 * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC) 214 * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
215 * @check_acl: optional callback to check for Posix ACLs 215 * @check_acl: optional callback to check for Posix ACLs
216 * @flags: IPERM_FLAG_ flags. 216 * @flags: IPERM_FLAG_ flags.
217 * 217 *
218 * Used to check for read/write/execute permissions on a file. 218 * Used to check for read/write/execute permissions on a file.
219 * We use "fsuid" for this, letting us set arbitrary permissions 219 * We use "fsuid" for this, letting us set arbitrary permissions
220 * for filesystem access without changing the "normal" uids which 220 * for filesystem access without changing the "normal" uids which
221 * are used for other things. 221 * are used for other things.
222 * 222 *
223 * generic_permission is rcu-walk aware. It returns -ECHILD in case an rcu-walk 223 * generic_permission is rcu-walk aware. It returns -ECHILD in case an rcu-walk
224 * request cannot be satisfied (eg. requires blocking or too much complexity). 224 * request cannot be satisfied (eg. requires blocking or too much complexity).
225 * It would then be called again in ref-walk mode. 225 * It would then be called again in ref-walk mode.
226 */ 226 */
227 int generic_permission(struct inode *inode, int mask, unsigned int flags, 227 int generic_permission(struct inode *inode, int mask, unsigned int flags,
228 int (*check_acl)(struct inode *inode, int mask, unsigned int flags)) 228 int (*check_acl)(struct inode *inode, int mask, unsigned int flags))
229 { 229 {
230 int ret; 230 int ret;
231 231
232 /* 232 /*
233 * Do the basic POSIX ACL permission checks. 233 * Do the basic POSIX ACL permission checks.
234 */ 234 */
235 ret = acl_permission_check(inode, mask, flags, check_acl); 235 ret = acl_permission_check(inode, mask, flags, check_acl);
236 if (ret != -EACCES) 236 if (ret != -EACCES)
237 return ret; 237 return ret;
238 238
239 /* 239 /*
240 * Read/write DACs are always overridable. 240 * Read/write DACs are always overridable.
241 * Executable DACs are overridable for all directories and 241 * Executable DACs are overridable for all directories and
242 * for non-directories that have least one exec bit set. 242 * for non-directories that have least one exec bit set.
243 */ 243 */
244 if (!(mask & MAY_EXEC) || execute_ok(inode)) 244 if (!(mask & MAY_EXEC) || execute_ok(inode))
245 if (ns_capable(inode_userns(inode), CAP_DAC_OVERRIDE)) 245 if (ns_capable(inode_userns(inode), CAP_DAC_OVERRIDE))
246 return 0; 246 return 0;
247 247
248 /* 248 /*
249 * Searching includes executable on directories, else just read. 249 * Searching includes executable on directories, else just read.
250 */ 250 */
251 mask &= MAY_READ | MAY_WRITE | MAY_EXEC; 251 mask &= MAY_READ | MAY_WRITE | MAY_EXEC;
252 if (mask == MAY_READ || (S_ISDIR(inode->i_mode) && !(mask & MAY_WRITE))) 252 if (mask == MAY_READ || (S_ISDIR(inode->i_mode) && !(mask & MAY_WRITE)))
253 if (ns_capable(inode_userns(inode), CAP_DAC_READ_SEARCH)) 253 if (ns_capable(inode_userns(inode), CAP_DAC_READ_SEARCH))
254 return 0; 254 return 0;
255 255
256 return -EACCES; 256 return -EACCES;
257 } 257 }
258 258
259 /** 259 /**
260 * inode_permission - check for access rights to a given inode 260 * inode_permission - check for access rights to a given inode
261 * @inode: inode to check permission on 261 * @inode: inode to check permission on
262 * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC) 262 * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
263 * 263 *
264 * Used to check for read/write/execute permissions on an inode. 264 * Used to check for read/write/execute permissions on an inode.
265 * We use "fsuid" for this, letting us set arbitrary permissions 265 * We use "fsuid" for this, letting us set arbitrary permissions
266 * for filesystem access without changing the "normal" uids which 266 * for filesystem access without changing the "normal" uids which
267 * are used for other things. 267 * are used for other things.
268 */ 268 */
269 int inode_permission(struct inode *inode, int mask) 269 int inode_permission(struct inode *inode, int mask)
270 { 270 {
271 int retval; 271 int retval;
272 272
273 if (mask & MAY_WRITE) { 273 if (mask & MAY_WRITE) {
274 umode_t mode = inode->i_mode; 274 umode_t mode = inode->i_mode;
275 275
276 /* 276 /*
277 * Nobody gets write access to a read-only fs. 277 * Nobody gets write access to a read-only fs.
278 */ 278 */
279 if (IS_RDONLY(inode) && 279 if (IS_RDONLY(inode) &&
280 (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))) 280 (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
281 return -EROFS; 281 return -EROFS;
282 282
283 /* 283 /*
284 * Nobody gets write access to an immutable file. 284 * Nobody gets write access to an immutable file.
285 */ 285 */
286 if (IS_IMMUTABLE(inode)) 286 if (IS_IMMUTABLE(inode))
287 return -EACCES; 287 return -EACCES;
288 } 288 }
289 289
290 if (inode->i_op->permission) 290 if (inode->i_op->permission)
291 retval = inode->i_op->permission(inode, mask, 0); 291 retval = inode->i_op->permission(inode, mask, 0);
292 else 292 else
293 retval = generic_permission(inode, mask, 0, 293 retval = generic_permission(inode, mask, 0,
294 inode->i_op->check_acl); 294 inode->i_op->check_acl);
295 295
296 if (retval) 296 if (retval)
297 return retval; 297 return retval;
298 298
299 retval = devcgroup_inode_permission(inode, mask); 299 retval = devcgroup_inode_permission(inode, mask);
300 if (retval) 300 if (retval)
301 return retval; 301 return retval;
302 302
303 return security_inode_permission(inode, mask); 303 return security_inode_permission(inode, mask);
304 } 304 }
305 305
306 /** 306 /**
307 * file_permission - check for additional access rights to a given file 307 * file_permission - check for additional access rights to a given file
308 * @file: file to check access rights for 308 * @file: file to check access rights for
309 * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC) 309 * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
310 * 310 *
311 * Used to check for read/write/execute permissions on an already opened 311 * Used to check for read/write/execute permissions on an already opened
312 * file. 312 * file.
313 * 313 *
314 * Note: 314 * Note:
315 * Do not use this function in new code. All access checks should 315 * Do not use this function in new code. All access checks should
316 * be done using inode_permission(). 316 * be done using inode_permission().
317 */ 317 */
318 int file_permission(struct file *file, int mask) 318 int file_permission(struct file *file, int mask)
319 { 319 {
320 return inode_permission(file->f_path.dentry->d_inode, mask); 320 return inode_permission(file->f_path.dentry->d_inode, mask);
321 } 321 }
322 322
323 /* 323 /*
324 * get_write_access() gets write permission for a file. 324 * get_write_access() gets write permission for a file.
325 * put_write_access() releases this write permission. 325 * put_write_access() releases this write permission.
326 * This is used for regular files. 326 * This is used for regular files.
327 * We cannot support write (and maybe mmap read-write shared) accesses and 327 * We cannot support write (and maybe mmap read-write shared) accesses and
328 * MAP_DENYWRITE mmappings simultaneously. The i_writecount field of an inode 328 * MAP_DENYWRITE mmappings simultaneously. The i_writecount field of an inode
329 * can have the following values: 329 * can have the following values:
330 * 0: no writers, no VM_DENYWRITE mappings 330 * 0: no writers, no VM_DENYWRITE mappings
331 * < 0: (-i_writecount) vm_area_structs with VM_DENYWRITE set exist 331 * < 0: (-i_writecount) vm_area_structs with VM_DENYWRITE set exist
332 * > 0: (i_writecount) users are writing to the file. 332 * > 0: (i_writecount) users are writing to the file.
333 * 333 *
334 * Normally we operate on that counter with atomic_{inc,dec} and it's safe 334 * Normally we operate on that counter with atomic_{inc,dec} and it's safe
335 * except for the cases where we don't hold i_writecount yet. Then we need to 335 * except for the cases where we don't hold i_writecount yet. Then we need to
336 * use {get,deny}_write_access() - these functions check the sign and refuse 336 * use {get,deny}_write_access() - these functions check the sign and refuse
337 * to do the change if sign is wrong. Exclusion between them is provided by 337 * to do the change if sign is wrong. Exclusion between them is provided by
338 * the inode->i_lock spinlock. 338 * the inode->i_lock spinlock.
339 */ 339 */
340 340
341 int get_write_access(struct inode * inode) 341 int get_write_access(struct inode * inode)
342 { 342 {
343 spin_lock(&inode->i_lock); 343 spin_lock(&inode->i_lock);
344 if (atomic_read(&inode->i_writecount) < 0) { 344 if (atomic_read(&inode->i_writecount) < 0) {
345 spin_unlock(&inode->i_lock); 345 spin_unlock(&inode->i_lock);
346 return -ETXTBSY; 346 return -ETXTBSY;
347 } 347 }
348 atomic_inc(&inode->i_writecount); 348 atomic_inc(&inode->i_writecount);
349 spin_unlock(&inode->i_lock); 349 spin_unlock(&inode->i_lock);
350 350
351 return 0; 351 return 0;
352 } 352 }
353 353
354 int deny_write_access(struct file * file) 354 int deny_write_access(struct file * file)
355 { 355 {
356 struct inode *inode = file->f_path.dentry->d_inode; 356 struct inode *inode = file->f_path.dentry->d_inode;
357 357
358 spin_lock(&inode->i_lock); 358 spin_lock(&inode->i_lock);
359 if (atomic_read(&inode->i_writecount) > 0) { 359 if (atomic_read(&inode->i_writecount) > 0) {
360 spin_unlock(&inode->i_lock); 360 spin_unlock(&inode->i_lock);
361 return -ETXTBSY; 361 return -ETXTBSY;
362 } 362 }
363 atomic_dec(&inode->i_writecount); 363 atomic_dec(&inode->i_writecount);
364 spin_unlock(&inode->i_lock); 364 spin_unlock(&inode->i_lock);
365 365
366 return 0; 366 return 0;
367 } 367 }
368 368
369 /** 369 /**
370 * path_get - get a reference to a path 370 * path_get - get a reference to a path
371 * @path: path to get the reference to 371 * @path: path to get the reference to
372 * 372 *
373 * Given a path increment the reference count to the dentry and the vfsmount. 373 * Given a path increment the reference count to the dentry and the vfsmount.
374 */ 374 */
375 void path_get(struct path *path) 375 void path_get(struct path *path)
376 { 376 {
377 mntget(path->mnt); 377 mntget(path->mnt);
378 dget(path->dentry); 378 dget(path->dentry);
379 } 379 }
380 EXPORT_SYMBOL(path_get); 380 EXPORT_SYMBOL(path_get);
381 381
382 /** 382 /**
383 * path_put - put a reference to a path 383 * path_put - put a reference to a path
384 * @path: path to put the reference to 384 * @path: path to put the reference to
385 * 385 *
386 * Given a path decrement the reference count to the dentry and the vfsmount. 386 * Given a path decrement the reference count to the dentry and the vfsmount.
387 */ 387 */
388 void path_put(struct path *path) 388 void path_put(struct path *path)
389 { 389 {
390 dput(path->dentry); 390 dput(path->dentry);
391 mntput(path->mnt); 391 mntput(path->mnt);
392 } 392 }
393 EXPORT_SYMBOL(path_put); 393 EXPORT_SYMBOL(path_put);
394 394
395 /* 395 /*
396 * Path walking has 2 modes, rcu-walk and ref-walk (see 396 * Path walking has 2 modes, rcu-walk and ref-walk (see
397 * Documentation/filesystems/path-lookup.txt). In situations when we can't 397 * Documentation/filesystems/path-lookup.txt). In situations when we can't
398 * continue in RCU mode, we attempt to drop out of rcu-walk mode and grab 398 * continue in RCU mode, we attempt to drop out of rcu-walk mode and grab
399 * normal reference counts on dentries and vfsmounts to transition to rcu-walk 399 * normal reference counts on dentries and vfsmounts to transition to rcu-walk
400 * mode. Refcounts are grabbed at the last known good point before rcu-walk 400 * mode. Refcounts are grabbed at the last known good point before rcu-walk
401 * got stuck, so ref-walk may continue from there. If this is not successful 401 * got stuck, so ref-walk may continue from there. If this is not successful
402 * (eg. a seqcount has changed), then failure is returned and it's up to caller 402 * (eg. a seqcount has changed), then failure is returned and it's up to caller
403 * to restart the path walk from the beginning in ref-walk mode. 403 * to restart the path walk from the beginning in ref-walk mode.
404 */ 404 */
405 405
406 /** 406 /**
407 * unlazy_walk - try to switch to ref-walk mode. 407 * unlazy_walk - try to switch to ref-walk mode.
408 * @nd: nameidata pathwalk data 408 * @nd: nameidata pathwalk data
409 * @dentry: child of nd->path.dentry or NULL 409 * @dentry: child of nd->path.dentry or NULL
410 * Returns: 0 on success, -ECHILD on failure 410 * Returns: 0 on success, -ECHILD on failure
411 * 411 *
412 * unlazy_walk attempts to legitimize the current nd->path, nd->root and dentry 412 * unlazy_walk attempts to legitimize the current nd->path, nd->root and dentry
413 * for ref-walk mode. @dentry must be a path found by a do_lookup call on 413 * for ref-walk mode. @dentry must be a path found by a do_lookup call on
414 * @nd or NULL. Must be called from rcu-walk context. 414 * @nd or NULL. Must be called from rcu-walk context.
415 */ 415 */
416 static int unlazy_walk(struct nameidata *nd, struct dentry *dentry) 416 static int unlazy_walk(struct nameidata *nd, struct dentry *dentry)
417 { 417 {
418 struct fs_struct *fs = current->fs; 418 struct fs_struct *fs = current->fs;
419 struct dentry *parent = nd->path.dentry; 419 struct dentry *parent = nd->path.dentry;
420 int want_root = 0; 420 int want_root = 0;
421 421
422 BUG_ON(!(nd->flags & LOOKUP_RCU)); 422 BUG_ON(!(nd->flags & LOOKUP_RCU));
423 if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT)) { 423 if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT)) {
424 want_root = 1; 424 want_root = 1;
425 spin_lock(&fs->lock); 425 spin_lock(&fs->lock);
426 if (nd->root.mnt != fs->root.mnt || 426 if (nd->root.mnt != fs->root.mnt ||
427 nd->root.dentry != fs->root.dentry) 427 nd->root.dentry != fs->root.dentry)
428 goto err_root; 428 goto err_root;
429 } 429 }
430 spin_lock(&parent->d_lock); 430 spin_lock(&parent->d_lock);
431 if (!dentry) { 431 if (!dentry) {
432 if (!__d_rcu_to_refcount(parent, nd->seq)) 432 if (!__d_rcu_to_refcount(parent, nd->seq))
433 goto err_parent; 433 goto err_parent;
434 BUG_ON(nd->inode != parent->d_inode); 434 BUG_ON(nd->inode != parent->d_inode);
435 } else { 435 } else {
436 if (dentry->d_parent != parent) 436 if (dentry->d_parent != parent)
437 goto err_parent; 437 goto err_parent;
438 spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED); 438 spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
439 if (!__d_rcu_to_refcount(dentry, nd->seq)) 439 if (!__d_rcu_to_refcount(dentry, nd->seq))
440 goto err_child; 440 goto err_child;
441 /* 441 /*
442 * If the sequence check on the child dentry passed, then 442 * If the sequence check on the child dentry passed, then
443 * the child has not been removed from its parent. This 443 * the child has not been removed from its parent. This
444 * means the parent dentry must be valid and able to take 444 * means the parent dentry must be valid and able to take
445 * a reference at this point. 445 * a reference at this point.
446 */ 446 */
447 BUG_ON(!IS_ROOT(dentry) && dentry->d_parent != parent); 447 BUG_ON(!IS_ROOT(dentry) && dentry->d_parent != parent);
448 BUG_ON(!parent->d_count); 448 BUG_ON(!parent->d_count);
449 parent->d_count++; 449 parent->d_count++;
450 spin_unlock(&dentry->d_lock); 450 spin_unlock(&dentry->d_lock);
451 } 451 }
452 spin_unlock(&parent->d_lock); 452 spin_unlock(&parent->d_lock);
453 if (want_root) { 453 if (want_root) {
454 path_get(&nd->root); 454 path_get(&nd->root);
455 spin_unlock(&fs->lock); 455 spin_unlock(&fs->lock);
456 } 456 }
457 mntget(nd->path.mnt); 457 mntget(nd->path.mnt);
458 458
459 rcu_read_unlock(); 459 rcu_read_unlock();
460 br_read_unlock(vfsmount_lock); 460 br_read_unlock(vfsmount_lock);
461 nd->flags &= ~LOOKUP_RCU; 461 nd->flags &= ~LOOKUP_RCU;
462 return 0; 462 return 0;
463 463
464 err_child: 464 err_child:
465 spin_unlock(&dentry->d_lock); 465 spin_unlock(&dentry->d_lock);
466 err_parent: 466 err_parent:
467 spin_unlock(&parent->d_lock); 467 spin_unlock(&parent->d_lock);
468 err_root: 468 err_root:
469 if (want_root) 469 if (want_root)
470 spin_unlock(&fs->lock); 470 spin_unlock(&fs->lock);
471 return -ECHILD; 471 return -ECHILD;
472 } 472 }
473 473
474 /** 474 /**
475 * release_open_intent - free up open intent resources 475 * release_open_intent - free up open intent resources
476 * @nd: pointer to nameidata 476 * @nd: pointer to nameidata
477 */ 477 */
478 void release_open_intent(struct nameidata *nd) 478 void release_open_intent(struct nameidata *nd)
479 { 479 {
480 struct file *file = nd->intent.open.file; 480 struct file *file = nd->intent.open.file;
481 481
482 if (file && !IS_ERR(file)) { 482 if (file && !IS_ERR(file)) {
483 if (file->f_path.dentry == NULL) 483 if (file->f_path.dentry == NULL)
484 put_filp(file); 484 put_filp(file);
485 else 485 else
486 fput(file); 486 fput(file);
487 } 487 }
488 } 488 }
489 489
490 static inline int d_revalidate(struct dentry *dentry, struct nameidata *nd) 490 static inline int d_revalidate(struct dentry *dentry, struct nameidata *nd)
491 { 491 {
492 return dentry->d_op->d_revalidate(dentry, nd); 492 return dentry->d_op->d_revalidate(dentry, nd);
493 } 493 }
494 494
495 static struct dentry * 495 static struct dentry *
496 do_revalidate(struct dentry *dentry, struct nameidata *nd) 496 do_revalidate(struct dentry *dentry, struct nameidata *nd)
497 { 497 {
498 int status = d_revalidate(dentry, nd); 498 int status = d_revalidate(dentry, nd);
499 if (unlikely(status <= 0)) { 499 if (unlikely(status <= 0)) {
500 /* 500 /*
501 * The dentry failed validation. 501 * The dentry failed validation.
502 * If d_revalidate returned 0 attempt to invalidate 502 * If d_revalidate returned 0 attempt to invalidate
503 * the dentry otherwise d_revalidate is asking us 503 * the dentry otherwise d_revalidate is asking us
504 * to return a fail status. 504 * to return a fail status.
505 */ 505 */
506 if (status < 0) { 506 if (status < 0) {
507 dput(dentry); 507 dput(dentry);
508 dentry = ERR_PTR(status); 508 dentry = ERR_PTR(status);
509 } else if (!d_invalidate(dentry)) { 509 } else if (!d_invalidate(dentry)) {
510 dput(dentry); 510 dput(dentry);
511 dentry = NULL; 511 dentry = NULL;
512 } 512 }
513 } 513 }
514 return dentry; 514 return dentry;
515 } 515 }
516 516
517 /** 517 /**
518 * complete_walk - successful completion of path walk 518 * complete_walk - successful completion of path walk
519 * @nd: pointer nameidata 519 * @nd: pointer nameidata
520 * 520 *
521 * If we had been in RCU mode, drop out of it and legitimize nd->path. 521 * If we had been in RCU mode, drop out of it and legitimize nd->path.
522 * Revalidate the final result, unless we'd already done that during 522 * Revalidate the final result, unless we'd already done that during
523 * the path walk or the filesystem doesn't ask for it. Return 0 on 523 * the path walk or the filesystem doesn't ask for it. Return 0 on
524 * success, -error on failure. In case of failure caller does not 524 * success, -error on failure. In case of failure caller does not
525 * need to drop nd->path. 525 * need to drop nd->path.
526 */ 526 */
527 static int complete_walk(struct nameidata *nd) 527 static int complete_walk(struct nameidata *nd)
528 { 528 {
529 struct dentry *dentry = nd->path.dentry; 529 struct dentry *dentry = nd->path.dentry;
530 int status; 530 int status;
531 531
532 if (nd->flags & LOOKUP_RCU) { 532 if (nd->flags & LOOKUP_RCU) {
533 nd->flags &= ~LOOKUP_RCU; 533 nd->flags &= ~LOOKUP_RCU;
534 if (!(nd->flags & LOOKUP_ROOT)) 534 if (!(nd->flags & LOOKUP_ROOT))
535 nd->root.mnt = NULL; 535 nd->root.mnt = NULL;
536 spin_lock(&dentry->d_lock); 536 spin_lock(&dentry->d_lock);
537 if (unlikely(!__d_rcu_to_refcount(dentry, nd->seq))) { 537 if (unlikely(!__d_rcu_to_refcount(dentry, nd->seq))) {
538 spin_unlock(&dentry->d_lock); 538 spin_unlock(&dentry->d_lock);
539 rcu_read_unlock(); 539 rcu_read_unlock();
540 br_read_unlock(vfsmount_lock); 540 br_read_unlock(vfsmount_lock);
541 return -ECHILD; 541 return -ECHILD;
542 } 542 }
543 BUG_ON(nd->inode != dentry->d_inode); 543 BUG_ON(nd->inode != dentry->d_inode);
544 spin_unlock(&dentry->d_lock); 544 spin_unlock(&dentry->d_lock);
545 mntget(nd->path.mnt); 545 mntget(nd->path.mnt);
546 rcu_read_unlock(); 546 rcu_read_unlock();
547 br_read_unlock(vfsmount_lock); 547 br_read_unlock(vfsmount_lock);
548 } 548 }
549 549
550 if (likely(!(nd->flags & LOOKUP_JUMPED))) 550 if (likely(!(nd->flags & LOOKUP_JUMPED)))
551 return 0; 551 return 0;
552 552
553 if (likely(!(dentry->d_flags & DCACHE_OP_REVALIDATE))) 553 if (likely(!(dentry->d_flags & DCACHE_OP_REVALIDATE)))
554 return 0; 554 return 0;
555 555
556 if (likely(!(dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT))) 556 if (likely(!(dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT)))
557 return 0; 557 return 0;
558 558
559 /* Note: we do not d_invalidate() */ 559 /* Note: we do not d_invalidate() */
560 status = d_revalidate(dentry, nd); 560 status = d_revalidate(dentry, nd);
561 if (status > 0) 561 if (status > 0)
562 return 0; 562 return 0;
563 563
564 if (!status) 564 if (!status)
565 status = -ESTALE; 565 status = -ESTALE;
566 566
567 path_put(&nd->path); 567 path_put(&nd->path);
568 return status; 568 return status;
569 } 569 }
570 570
571 /* 571 /*
572 * Short-cut version of permission(), for calling on directories 572 * Short-cut version of permission(), for calling on directories
573 * during pathname resolution. Combines parts of permission() 573 * during pathname resolution. Combines parts of permission()
574 * and generic_permission(), and tests ONLY for MAY_EXEC permission. 574 * and generic_permission(), and tests ONLY for MAY_EXEC permission.
575 * 575 *
576 * If appropriate, check DAC only. If not appropriate, or 576 * If appropriate, check DAC only. If not appropriate, or
577 * short-cut DAC fails, then call ->permission() to do more 577 * short-cut DAC fails, then call ->permission() to do more
578 * complete permission check. 578 * complete permission check.
579 */ 579 */
580 static inline int exec_permission(struct inode *inode, unsigned int flags) 580 static inline int exec_permission(struct inode *inode, unsigned int flags)
581 { 581 {
582 int ret; 582 int ret;
583 struct user_namespace *ns = inode_userns(inode); 583 struct user_namespace *ns = inode_userns(inode);
584 584
585 if (inode->i_op->permission) { 585 if (inode->i_op->permission) {
586 ret = inode->i_op->permission(inode, MAY_EXEC, flags); 586 ret = inode->i_op->permission(inode, MAY_EXEC, flags);
587 if (likely(!ret))
588 goto ok;
587 } else { 589 } else {
588 ret = acl_permission_check(inode, MAY_EXEC, flags, 590 ret = acl_permission_check(inode, MAY_EXEC, flags,
589 inode->i_op->check_acl); 591 inode->i_op->check_acl);
592 if (likely(!ret))
593 goto ok;
594 if (ret != -EACCES)
595 return ret;
596 if (ns_capable(ns, CAP_DAC_OVERRIDE) ||
597 ns_capable(ns, CAP_DAC_READ_SEARCH))
598 goto ok;
590 } 599 }
591 if (likely(!ret))
592 goto ok;
593 if (ret == -ECHILD)
594 return ret;
595
596 if (ns_capable(ns, CAP_DAC_OVERRIDE) ||
597 ns_capable(ns, CAP_DAC_READ_SEARCH))
598 goto ok;
599
600 return ret; 600 return ret;
601 ok: 601 ok:
602 return security_inode_exec_permission(inode, flags); 602 return security_inode_exec_permission(inode, flags);
603 } 603 }
604 604
605 static __always_inline void set_root(struct nameidata *nd) 605 static __always_inline void set_root(struct nameidata *nd)
606 { 606 {
607 if (!nd->root.mnt) 607 if (!nd->root.mnt)
608 get_fs_root(current->fs, &nd->root); 608 get_fs_root(current->fs, &nd->root);
609 } 609 }
610 610
611 static int link_path_walk(const char *, struct nameidata *); 611 static int link_path_walk(const char *, struct nameidata *);
612 612
613 static __always_inline void set_root_rcu(struct nameidata *nd) 613 static __always_inline void set_root_rcu(struct nameidata *nd)
614 { 614 {
615 if (!nd->root.mnt) { 615 if (!nd->root.mnt) {
616 struct fs_struct *fs = current->fs; 616 struct fs_struct *fs = current->fs;
617 unsigned seq; 617 unsigned seq;
618 618
619 do { 619 do {
620 seq = read_seqcount_begin(&fs->seq); 620 seq = read_seqcount_begin(&fs->seq);
621 nd->root = fs->root; 621 nd->root = fs->root;
622 nd->seq = __read_seqcount_begin(&nd->root.dentry->d_seq); 622 nd->seq = __read_seqcount_begin(&nd->root.dentry->d_seq);
623 } while (read_seqcount_retry(&fs->seq, seq)); 623 } while (read_seqcount_retry(&fs->seq, seq));
624 } 624 }
625 } 625 }
626 626
627 static __always_inline int __vfs_follow_link(struct nameidata *nd, const char *link) 627 static __always_inline int __vfs_follow_link(struct nameidata *nd, const char *link)
628 { 628 {
629 int ret; 629 int ret;
630 630
631 if (IS_ERR(link)) 631 if (IS_ERR(link))
632 goto fail; 632 goto fail;
633 633
634 if (*link == '/') { 634 if (*link == '/') {
635 set_root(nd); 635 set_root(nd);
636 path_put(&nd->path); 636 path_put(&nd->path);
637 nd->path = nd->root; 637 nd->path = nd->root;
638 path_get(&nd->root); 638 path_get(&nd->root);
639 nd->flags |= LOOKUP_JUMPED; 639 nd->flags |= LOOKUP_JUMPED;
640 } 640 }
641 nd->inode = nd->path.dentry->d_inode; 641 nd->inode = nd->path.dentry->d_inode;
642 642
643 ret = link_path_walk(link, nd); 643 ret = link_path_walk(link, nd);
644 return ret; 644 return ret;
645 fail: 645 fail:
646 path_put(&nd->path); 646 path_put(&nd->path);
647 return PTR_ERR(link); 647 return PTR_ERR(link);
648 } 648 }
649 649
650 static void path_put_conditional(struct path *path, struct nameidata *nd) 650 static void path_put_conditional(struct path *path, struct nameidata *nd)
651 { 651 {
652 dput(path->dentry); 652 dput(path->dentry);
653 if (path->mnt != nd->path.mnt) 653 if (path->mnt != nd->path.mnt)
654 mntput(path->mnt); 654 mntput(path->mnt);
655 } 655 }
656 656
657 static inline void path_to_nameidata(const struct path *path, 657 static inline void path_to_nameidata(const struct path *path,
658 struct nameidata *nd) 658 struct nameidata *nd)
659 { 659 {
660 if (!(nd->flags & LOOKUP_RCU)) { 660 if (!(nd->flags & LOOKUP_RCU)) {
661 dput(nd->path.dentry); 661 dput(nd->path.dentry);
662 if (nd->path.mnt != path->mnt) 662 if (nd->path.mnt != path->mnt)
663 mntput(nd->path.mnt); 663 mntput(nd->path.mnt);
664 } 664 }
665 nd->path.mnt = path->mnt; 665 nd->path.mnt = path->mnt;
666 nd->path.dentry = path->dentry; 666 nd->path.dentry = path->dentry;
667 } 667 }
668 668
669 static inline void put_link(struct nameidata *nd, struct path *link, void *cookie) 669 static inline void put_link(struct nameidata *nd, struct path *link, void *cookie)
670 { 670 {
671 struct inode *inode = link->dentry->d_inode; 671 struct inode *inode = link->dentry->d_inode;
672 if (!IS_ERR(cookie) && inode->i_op->put_link) 672 if (!IS_ERR(cookie) && inode->i_op->put_link)
673 inode->i_op->put_link(link->dentry, nd, cookie); 673 inode->i_op->put_link(link->dentry, nd, cookie);
674 path_put(link); 674 path_put(link);
675 } 675 }
676 676
677 static __always_inline int 677 static __always_inline int
678 follow_link(struct path *link, struct nameidata *nd, void **p) 678 follow_link(struct path *link, struct nameidata *nd, void **p)
679 { 679 {
680 int error; 680 int error;
681 struct dentry *dentry = link->dentry; 681 struct dentry *dentry = link->dentry;
682 682
683 BUG_ON(nd->flags & LOOKUP_RCU); 683 BUG_ON(nd->flags & LOOKUP_RCU);
684 684
685 if (link->mnt == nd->path.mnt) 685 if (link->mnt == nd->path.mnt)
686 mntget(link->mnt); 686 mntget(link->mnt);
687 687
688 if (unlikely(current->total_link_count >= 40)) { 688 if (unlikely(current->total_link_count >= 40)) {
689 *p = ERR_PTR(-ELOOP); /* no ->put_link(), please */ 689 *p = ERR_PTR(-ELOOP); /* no ->put_link(), please */
690 path_put(&nd->path); 690 path_put(&nd->path);
691 return -ELOOP; 691 return -ELOOP;
692 } 692 }
693 cond_resched(); 693 cond_resched();
694 current->total_link_count++; 694 current->total_link_count++;
695 695
696 touch_atime(link->mnt, dentry); 696 touch_atime(link->mnt, dentry);
697 nd_set_link(nd, NULL); 697 nd_set_link(nd, NULL);
698 698
699 error = security_inode_follow_link(link->dentry, nd); 699 error = security_inode_follow_link(link->dentry, nd);
700 if (error) { 700 if (error) {
701 *p = ERR_PTR(error); /* no ->put_link(), please */ 701 *p = ERR_PTR(error); /* no ->put_link(), please */
702 path_put(&nd->path); 702 path_put(&nd->path);
703 return error; 703 return error;
704 } 704 }
705 705
706 nd->last_type = LAST_BIND; 706 nd->last_type = LAST_BIND;
707 *p = dentry->d_inode->i_op->follow_link(dentry, nd); 707 *p = dentry->d_inode->i_op->follow_link(dentry, nd);
708 error = PTR_ERR(*p); 708 error = PTR_ERR(*p);
709 if (!IS_ERR(*p)) { 709 if (!IS_ERR(*p)) {
710 char *s = nd_get_link(nd); 710 char *s = nd_get_link(nd);
711 error = 0; 711 error = 0;
712 if (s) 712 if (s)
713 error = __vfs_follow_link(nd, s); 713 error = __vfs_follow_link(nd, s);
714 else if (nd->last_type == LAST_BIND) { 714 else if (nd->last_type == LAST_BIND) {
715 nd->flags |= LOOKUP_JUMPED; 715 nd->flags |= LOOKUP_JUMPED;
716 nd->inode = nd->path.dentry->d_inode; 716 nd->inode = nd->path.dentry->d_inode;
717 if (nd->inode->i_op->follow_link) { 717 if (nd->inode->i_op->follow_link) {
718 /* stepped on a _really_ weird one */ 718 /* stepped on a _really_ weird one */
719 path_put(&nd->path); 719 path_put(&nd->path);
720 error = -ELOOP; 720 error = -ELOOP;
721 } 721 }
722 } 722 }
723 } 723 }
724 return error; 724 return error;
725 } 725 }
726 726
727 static int follow_up_rcu(struct path *path) 727 static int follow_up_rcu(struct path *path)
728 { 728 {
729 struct vfsmount *parent; 729 struct vfsmount *parent;
730 struct dentry *mountpoint; 730 struct dentry *mountpoint;
731 731
732 parent = path->mnt->mnt_parent; 732 parent = path->mnt->mnt_parent;
733 if (parent == path->mnt) 733 if (parent == path->mnt)
734 return 0; 734 return 0;
735 mountpoint = path->mnt->mnt_mountpoint; 735 mountpoint = path->mnt->mnt_mountpoint;
736 path->dentry = mountpoint; 736 path->dentry = mountpoint;
737 path->mnt = parent; 737 path->mnt = parent;
738 return 1; 738 return 1;
739 } 739 }
740 740
741 int follow_up(struct path *path) 741 int follow_up(struct path *path)
742 { 742 {
743 struct vfsmount *parent; 743 struct vfsmount *parent;
744 struct dentry *mountpoint; 744 struct dentry *mountpoint;
745 745
746 br_read_lock(vfsmount_lock); 746 br_read_lock(vfsmount_lock);
747 parent = path->mnt->mnt_parent; 747 parent = path->mnt->mnt_parent;
748 if (parent == path->mnt) { 748 if (parent == path->mnt) {
749 br_read_unlock(vfsmount_lock); 749 br_read_unlock(vfsmount_lock);
750 return 0; 750 return 0;
751 } 751 }
752 mntget(parent); 752 mntget(parent);
753 mountpoint = dget(path->mnt->mnt_mountpoint); 753 mountpoint = dget(path->mnt->mnt_mountpoint);
754 br_read_unlock(vfsmount_lock); 754 br_read_unlock(vfsmount_lock);
755 dput(path->dentry); 755 dput(path->dentry);
756 path->dentry = mountpoint; 756 path->dentry = mountpoint;
757 mntput(path->mnt); 757 mntput(path->mnt);
758 path->mnt = parent; 758 path->mnt = parent;
759 return 1; 759 return 1;
760 } 760 }
761 761
762 /* 762 /*
763 * Perform an automount 763 * Perform an automount
764 * - return -EISDIR to tell follow_managed() to stop and return the path we 764 * - return -EISDIR to tell follow_managed() to stop and return the path we
765 * were called with. 765 * were called with.
766 */ 766 */
767 static int follow_automount(struct path *path, unsigned flags, 767 static int follow_automount(struct path *path, unsigned flags,
768 bool *need_mntput) 768 bool *need_mntput)
769 { 769 {
770 struct vfsmount *mnt; 770 struct vfsmount *mnt;
771 int err; 771 int err;
772 772
773 if (!path->dentry->d_op || !path->dentry->d_op->d_automount) 773 if (!path->dentry->d_op || !path->dentry->d_op->d_automount)
774 return -EREMOTE; 774 return -EREMOTE;
775 775
776 /* We don't want to mount if someone supplied AT_NO_AUTOMOUNT 776 /* We don't want to mount if someone supplied AT_NO_AUTOMOUNT
777 * and this is the terminal part of the path. 777 * and this is the terminal part of the path.
778 */ 778 */
779 if ((flags & LOOKUP_NO_AUTOMOUNT) && !(flags & LOOKUP_CONTINUE)) 779 if ((flags & LOOKUP_NO_AUTOMOUNT) && !(flags & LOOKUP_CONTINUE))
780 return -EISDIR; /* we actually want to stop here */ 780 return -EISDIR; /* we actually want to stop here */
781 781
782 /* We want to mount if someone is trying to open/create a file of any 782 /* We want to mount if someone is trying to open/create a file of any
783 * type under the mountpoint, wants to traverse through the mountpoint 783 * type under the mountpoint, wants to traverse through the mountpoint
784 * or wants to open the mounted directory. 784 * or wants to open the mounted directory.
785 * 785 *
786 * We don't want to mount if someone's just doing a stat and they've 786 * We don't want to mount if someone's just doing a stat and they've
787 * set AT_SYMLINK_NOFOLLOW - unless they're stat'ing a directory and 787 * set AT_SYMLINK_NOFOLLOW - unless they're stat'ing a directory and
788 * appended a '/' to the name. 788 * appended a '/' to the name.
789 */ 789 */
790 if (!(flags & LOOKUP_FOLLOW) && 790 if (!(flags & LOOKUP_FOLLOW) &&
791 !(flags & (LOOKUP_CONTINUE | LOOKUP_DIRECTORY | 791 !(flags & (LOOKUP_CONTINUE | LOOKUP_DIRECTORY |
792 LOOKUP_OPEN | LOOKUP_CREATE))) 792 LOOKUP_OPEN | LOOKUP_CREATE)))
793 return -EISDIR; 793 return -EISDIR;
794 794
795 current->total_link_count++; 795 current->total_link_count++;
796 if (current->total_link_count >= 40) 796 if (current->total_link_count >= 40)
797 return -ELOOP; 797 return -ELOOP;
798 798
799 mnt = path->dentry->d_op->d_automount(path); 799 mnt = path->dentry->d_op->d_automount(path);
800 if (IS_ERR(mnt)) { 800 if (IS_ERR(mnt)) {
801 /* 801 /*
802 * The filesystem is allowed to return -EISDIR here to indicate 802 * The filesystem is allowed to return -EISDIR here to indicate
803 * it doesn't want to automount. For instance, autofs would do 803 * it doesn't want to automount. For instance, autofs would do
804 * this so that its userspace daemon can mount on this dentry. 804 * this so that its userspace daemon can mount on this dentry.
805 * 805 *
806 * However, we can only permit this if it's a terminal point in 806 * However, we can only permit this if it's a terminal point in
807 * the path being looked up; if it wasn't then the remainder of 807 * the path being looked up; if it wasn't then the remainder of
808 * the path is inaccessible and we should say so. 808 * the path is inaccessible and we should say so.
809 */ 809 */
810 if (PTR_ERR(mnt) == -EISDIR && (flags & LOOKUP_CONTINUE)) 810 if (PTR_ERR(mnt) == -EISDIR && (flags & LOOKUP_CONTINUE))
811 return -EREMOTE; 811 return -EREMOTE;
812 return PTR_ERR(mnt); 812 return PTR_ERR(mnt);
813 } 813 }
814 814
815 if (!mnt) /* mount collision */ 815 if (!mnt) /* mount collision */
816 return 0; 816 return 0;
817 817
818 if (!*need_mntput) { 818 if (!*need_mntput) {
819 /* lock_mount() may release path->mnt on error */ 819 /* lock_mount() may release path->mnt on error */
820 mntget(path->mnt); 820 mntget(path->mnt);
821 *need_mntput = true; 821 *need_mntput = true;
822 } 822 }
823 err = finish_automount(mnt, path); 823 err = finish_automount(mnt, path);
824 824
825 switch (err) { 825 switch (err) {
826 case -EBUSY: 826 case -EBUSY:
827 /* Someone else made a mount here whilst we were busy */ 827 /* Someone else made a mount here whilst we were busy */
828 return 0; 828 return 0;
829 case 0: 829 case 0:
830 path_put(path); 830 path_put(path);
831 path->mnt = mnt; 831 path->mnt = mnt;
832 path->dentry = dget(mnt->mnt_root); 832 path->dentry = dget(mnt->mnt_root);
833 return 0; 833 return 0;
834 default: 834 default:
835 return err; 835 return err;
836 } 836 }
837 837
838 } 838 }
839 839
840 /* 840 /*
841 * Handle a dentry that is managed in some way. 841 * Handle a dentry that is managed in some way.
842 * - Flagged for transit management (autofs) 842 * - Flagged for transit management (autofs)
843 * - Flagged as mountpoint 843 * - Flagged as mountpoint
844 * - Flagged as automount point 844 * - Flagged as automount point
845 * 845 *
846 * This may only be called in refwalk mode. 846 * This may only be called in refwalk mode.
847 * 847 *
848 * Serialization is taken care of in namespace.c 848 * Serialization is taken care of in namespace.c
849 */ 849 */
850 static int follow_managed(struct path *path, unsigned flags) 850 static int follow_managed(struct path *path, unsigned flags)
851 { 851 {
852 struct vfsmount *mnt = path->mnt; /* held by caller, must be left alone */ 852 struct vfsmount *mnt = path->mnt; /* held by caller, must be left alone */
853 unsigned managed; 853 unsigned managed;
854 bool need_mntput = false; 854 bool need_mntput = false;
855 int ret = 0; 855 int ret = 0;
856 856
857 /* Given that we're not holding a lock here, we retain the value in a 857 /* Given that we're not holding a lock here, we retain the value in a
858 * local variable for each dentry as we look at it so that we don't see 858 * local variable for each dentry as we look at it so that we don't see
859 * the components of that value change under us */ 859 * the components of that value change under us */
860 while (managed = ACCESS_ONCE(path->dentry->d_flags), 860 while (managed = ACCESS_ONCE(path->dentry->d_flags),
861 managed &= DCACHE_MANAGED_DENTRY, 861 managed &= DCACHE_MANAGED_DENTRY,
862 unlikely(managed != 0)) { 862 unlikely(managed != 0)) {
863 /* Allow the filesystem to manage the transit without i_mutex 863 /* Allow the filesystem to manage the transit without i_mutex
864 * being held. */ 864 * being held. */
865 if (managed & DCACHE_MANAGE_TRANSIT) { 865 if (managed & DCACHE_MANAGE_TRANSIT) {
866 BUG_ON(!path->dentry->d_op); 866 BUG_ON(!path->dentry->d_op);
867 BUG_ON(!path->dentry->d_op->d_manage); 867 BUG_ON(!path->dentry->d_op->d_manage);
868 ret = path->dentry->d_op->d_manage(path->dentry, false); 868 ret = path->dentry->d_op->d_manage(path->dentry, false);
869 if (ret < 0) 869 if (ret < 0)
870 break; 870 break;
871 } 871 }
872 872
873 /* Transit to a mounted filesystem. */ 873 /* Transit to a mounted filesystem. */
874 if (managed & DCACHE_MOUNTED) { 874 if (managed & DCACHE_MOUNTED) {
875 struct vfsmount *mounted = lookup_mnt(path); 875 struct vfsmount *mounted = lookup_mnt(path);
876 if (mounted) { 876 if (mounted) {
877 dput(path->dentry); 877 dput(path->dentry);
878 if (need_mntput) 878 if (need_mntput)
879 mntput(path->mnt); 879 mntput(path->mnt);
880 path->mnt = mounted; 880 path->mnt = mounted;
881 path->dentry = dget(mounted->mnt_root); 881 path->dentry = dget(mounted->mnt_root);
882 need_mntput = true; 882 need_mntput = true;
883 continue; 883 continue;
884 } 884 }
885 885
886 /* Something is mounted on this dentry in another 886 /* Something is mounted on this dentry in another
887 * namespace and/or whatever was mounted there in this 887 * namespace and/or whatever was mounted there in this
888 * namespace got unmounted before we managed to get the 888 * namespace got unmounted before we managed to get the
889 * vfsmount_lock */ 889 * vfsmount_lock */
890 } 890 }
891 891
892 /* Handle an automount point */ 892 /* Handle an automount point */
893 if (managed & DCACHE_NEED_AUTOMOUNT) { 893 if (managed & DCACHE_NEED_AUTOMOUNT) {
894 ret = follow_automount(path, flags, &need_mntput); 894 ret = follow_automount(path, flags, &need_mntput);
895 if (ret < 0) 895 if (ret < 0)
896 break; 896 break;
897 continue; 897 continue;
898 } 898 }
899 899
900 /* We didn't change the current path point */ 900 /* We didn't change the current path point */
901 break; 901 break;
902 } 902 }
903 903
904 if (need_mntput && path->mnt == mnt) 904 if (need_mntput && path->mnt == mnt)
905 mntput(path->mnt); 905 mntput(path->mnt);
906 if (ret == -EISDIR) 906 if (ret == -EISDIR)
907 ret = 0; 907 ret = 0;
908 return ret; 908 return ret;
909 } 909 }
910 910
911 int follow_down_one(struct path *path) 911 int follow_down_one(struct path *path)
912 { 912 {
913 struct vfsmount *mounted; 913 struct vfsmount *mounted;
914 914
915 mounted = lookup_mnt(path); 915 mounted = lookup_mnt(path);
916 if (mounted) { 916 if (mounted) {
917 dput(path->dentry); 917 dput(path->dentry);
918 mntput(path->mnt); 918 mntput(path->mnt);
919 path->mnt = mounted; 919 path->mnt = mounted;
920 path->dentry = dget(mounted->mnt_root); 920 path->dentry = dget(mounted->mnt_root);
921 return 1; 921 return 1;
922 } 922 }
923 return 0; 923 return 0;
924 } 924 }
925 925
926 static inline bool managed_dentry_might_block(struct dentry *dentry) 926 static inline bool managed_dentry_might_block(struct dentry *dentry)
927 { 927 {
928 return (dentry->d_flags & DCACHE_MANAGE_TRANSIT && 928 return (dentry->d_flags & DCACHE_MANAGE_TRANSIT &&
929 dentry->d_op->d_manage(dentry, true) < 0); 929 dentry->d_op->d_manage(dentry, true) < 0);
930 } 930 }
931 931
932 /* 932 /*
933 * Try to skip to top of mountpoint pile in rcuwalk mode. Fail if 933 * Try to skip to top of mountpoint pile in rcuwalk mode. Fail if
934 * we meet a managed dentry that would need blocking. 934 * we meet a managed dentry that would need blocking.
935 */ 935 */
936 static bool __follow_mount_rcu(struct nameidata *nd, struct path *path, 936 static bool __follow_mount_rcu(struct nameidata *nd, struct path *path,
937 struct inode **inode) 937 struct inode **inode)
938 { 938 {
939 for (;;) { 939 for (;;) {
940 struct vfsmount *mounted; 940 struct vfsmount *mounted;
941 /* 941 /*
942 * Don't forget we might have a non-mountpoint managed dentry 942 * Don't forget we might have a non-mountpoint managed dentry
943 * that wants to block transit. 943 * that wants to block transit.
944 */ 944 */
945 if (unlikely(managed_dentry_might_block(path->dentry))) 945 if (unlikely(managed_dentry_might_block(path->dentry)))
946 return false; 946 return false;
947 947
948 if (!d_mountpoint(path->dentry)) 948 if (!d_mountpoint(path->dentry))
949 break; 949 break;
950 950
951 mounted = __lookup_mnt(path->mnt, path->dentry, 1); 951 mounted = __lookup_mnt(path->mnt, path->dentry, 1);
952 if (!mounted) 952 if (!mounted)
953 break; 953 break;
954 path->mnt = mounted; 954 path->mnt = mounted;
955 path->dentry = mounted->mnt_root; 955 path->dentry = mounted->mnt_root;
956 nd->seq = read_seqcount_begin(&path->dentry->d_seq); 956 nd->seq = read_seqcount_begin(&path->dentry->d_seq);
957 /* 957 /*
958 * Update the inode too. We don't need to re-check the 958 * Update the inode too. We don't need to re-check the
959 * dentry sequence number here after this d_inode read, 959 * dentry sequence number here after this d_inode read,
960 * because a mount-point is always pinned. 960 * because a mount-point is always pinned.
961 */ 961 */
962 *inode = path->dentry->d_inode; 962 *inode = path->dentry->d_inode;
963 } 963 }
964 return true; 964 return true;
965 } 965 }
966 966
967 static void follow_mount_rcu(struct nameidata *nd) 967 static void follow_mount_rcu(struct nameidata *nd)
968 { 968 {
969 while (d_mountpoint(nd->path.dentry)) { 969 while (d_mountpoint(nd->path.dentry)) {
970 struct vfsmount *mounted; 970 struct vfsmount *mounted;
971 mounted = __lookup_mnt(nd->path.mnt, nd->path.dentry, 1); 971 mounted = __lookup_mnt(nd->path.mnt, nd->path.dentry, 1);
972 if (!mounted) 972 if (!mounted)
973 break; 973 break;
974 nd->path.mnt = mounted; 974 nd->path.mnt = mounted;
975 nd->path.dentry = mounted->mnt_root; 975 nd->path.dentry = mounted->mnt_root;
976 nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq); 976 nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
977 } 977 }
978 } 978 }
979 979
980 static int follow_dotdot_rcu(struct nameidata *nd) 980 static int follow_dotdot_rcu(struct nameidata *nd)
981 { 981 {
982 set_root_rcu(nd); 982 set_root_rcu(nd);
983 983
984 while (1) { 984 while (1) {
985 if (nd->path.dentry == nd->root.dentry && 985 if (nd->path.dentry == nd->root.dentry &&
986 nd->path.mnt == nd->root.mnt) { 986 nd->path.mnt == nd->root.mnt) {
987 break; 987 break;
988 } 988 }
989 if (nd->path.dentry != nd->path.mnt->mnt_root) { 989 if (nd->path.dentry != nd->path.mnt->mnt_root) {
990 struct dentry *old = nd->path.dentry; 990 struct dentry *old = nd->path.dentry;
991 struct dentry *parent = old->d_parent; 991 struct dentry *parent = old->d_parent;
992 unsigned seq; 992 unsigned seq;
993 993
994 seq = read_seqcount_begin(&parent->d_seq); 994 seq = read_seqcount_begin(&parent->d_seq);
995 if (read_seqcount_retry(&old->d_seq, nd->seq)) 995 if (read_seqcount_retry(&old->d_seq, nd->seq))
996 goto failed; 996 goto failed;
997 nd->path.dentry = parent; 997 nd->path.dentry = parent;
998 nd->seq = seq; 998 nd->seq = seq;
999 break; 999 break;
1000 } 1000 }
1001 if (!follow_up_rcu(&nd->path)) 1001 if (!follow_up_rcu(&nd->path))
1002 break; 1002 break;
1003 nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq); 1003 nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
1004 } 1004 }
1005 follow_mount_rcu(nd); 1005 follow_mount_rcu(nd);
1006 nd->inode = nd->path.dentry->d_inode; 1006 nd->inode = nd->path.dentry->d_inode;
1007 return 0; 1007 return 0;
1008 1008
1009 failed: 1009 failed:
1010 nd->flags &= ~LOOKUP_RCU; 1010 nd->flags &= ~LOOKUP_RCU;
1011 if (!(nd->flags & LOOKUP_ROOT)) 1011 if (!(nd->flags & LOOKUP_ROOT))
1012 nd->root.mnt = NULL; 1012 nd->root.mnt = NULL;
1013 rcu_read_unlock(); 1013 rcu_read_unlock();
1014 br_read_unlock(vfsmount_lock); 1014 br_read_unlock(vfsmount_lock);
1015 return -ECHILD; 1015 return -ECHILD;
1016 } 1016 }
1017 1017
1018 /* 1018 /*
1019 * Follow down to the covering mount currently visible to userspace. At each 1019 * Follow down to the covering mount currently visible to userspace. At each
1020 * point, the filesystem owning that dentry may be queried as to whether the 1020 * point, the filesystem owning that dentry may be queried as to whether the
1021 * caller is permitted to proceed or not. 1021 * caller is permitted to proceed or not.
1022 */ 1022 */
1023 int follow_down(struct path *path) 1023 int follow_down(struct path *path)
1024 { 1024 {
1025 unsigned managed; 1025 unsigned managed;
1026 int ret; 1026 int ret;
1027 1027
1028 while (managed = ACCESS_ONCE(path->dentry->d_flags), 1028 while (managed = ACCESS_ONCE(path->dentry->d_flags),
1029 unlikely(managed & DCACHE_MANAGED_DENTRY)) { 1029 unlikely(managed & DCACHE_MANAGED_DENTRY)) {
1030 /* Allow the filesystem to manage the transit without i_mutex 1030 /* Allow the filesystem to manage the transit without i_mutex
1031 * being held. 1031 * being held.
1032 * 1032 *
1033 * We indicate to the filesystem if someone is trying to mount 1033 * We indicate to the filesystem if someone is trying to mount
1034 * something here. This gives autofs the chance to deny anyone 1034 * something here. This gives autofs the chance to deny anyone
1035 * other than its daemon the right to mount on its 1035 * other than its daemon the right to mount on its
1036 * superstructure. 1036 * superstructure.
1037 * 1037 *
1038 * The filesystem may sleep at this point. 1038 * The filesystem may sleep at this point.
1039 */ 1039 */
1040 if (managed & DCACHE_MANAGE_TRANSIT) { 1040 if (managed & DCACHE_MANAGE_TRANSIT) {
1041 BUG_ON(!path->dentry->d_op); 1041 BUG_ON(!path->dentry->d_op);
1042 BUG_ON(!path->dentry->d_op->d_manage); 1042 BUG_ON(!path->dentry->d_op->d_manage);
1043 ret = path->dentry->d_op->d_manage( 1043 ret = path->dentry->d_op->d_manage(
1044 path->dentry, false); 1044 path->dentry, false);
1045 if (ret < 0) 1045 if (ret < 0)
1046 return ret == -EISDIR ? 0 : ret; 1046 return ret == -EISDIR ? 0 : ret;
1047 } 1047 }
1048 1048
1049 /* Transit to a mounted filesystem. */ 1049 /* Transit to a mounted filesystem. */
1050 if (managed & DCACHE_MOUNTED) { 1050 if (managed & DCACHE_MOUNTED) {
1051 struct vfsmount *mounted = lookup_mnt(path); 1051 struct vfsmount *mounted = lookup_mnt(path);
1052 if (!mounted) 1052 if (!mounted)
1053 break; 1053 break;
1054 dput(path->dentry); 1054 dput(path->dentry);
1055 mntput(path->mnt); 1055 mntput(path->mnt);
1056 path->mnt = mounted; 1056 path->mnt = mounted;
1057 path->dentry = dget(mounted->mnt_root); 1057 path->dentry = dget(mounted->mnt_root);
1058 continue; 1058 continue;
1059 } 1059 }
1060 1060
1061 /* Don't handle automount points here */ 1061 /* Don't handle automount points here */
1062 break; 1062 break;
1063 } 1063 }
1064 return 0; 1064 return 0;
1065 } 1065 }
1066 1066
1067 /* 1067 /*
1068 * Skip to top of mountpoint pile in refwalk mode for follow_dotdot() 1068 * Skip to top of mountpoint pile in refwalk mode for follow_dotdot()
1069 */ 1069 */
1070 static void follow_mount(struct path *path) 1070 static void follow_mount(struct path *path)
1071 { 1071 {
1072 while (d_mountpoint(path->dentry)) { 1072 while (d_mountpoint(path->dentry)) {
1073 struct vfsmount *mounted = lookup_mnt(path); 1073 struct vfsmount *mounted = lookup_mnt(path);
1074 if (!mounted) 1074 if (!mounted)
1075 break; 1075 break;
1076 dput(path->dentry); 1076 dput(path->dentry);
1077 mntput(path->mnt); 1077 mntput(path->mnt);
1078 path->mnt = mounted; 1078 path->mnt = mounted;
1079 path->dentry = dget(mounted->mnt_root); 1079 path->dentry = dget(mounted->mnt_root);
1080 } 1080 }
1081 } 1081 }
1082 1082
1083 static void follow_dotdot(struct nameidata *nd) 1083 static void follow_dotdot(struct nameidata *nd)
1084 { 1084 {
1085 set_root(nd); 1085 set_root(nd);
1086 1086
1087 while(1) { 1087 while(1) {
1088 struct dentry *old = nd->path.dentry; 1088 struct dentry *old = nd->path.dentry;
1089 1089
1090 if (nd->path.dentry == nd->root.dentry && 1090 if (nd->path.dentry == nd->root.dentry &&
1091 nd->path.mnt == nd->root.mnt) { 1091 nd->path.mnt == nd->root.mnt) {
1092 break; 1092 break;
1093 } 1093 }
1094 if (nd->path.dentry != nd->path.mnt->mnt_root) { 1094 if (nd->path.dentry != nd->path.mnt->mnt_root) {
1095 /* rare case of legitimate dget_parent()... */ 1095 /* rare case of legitimate dget_parent()... */
1096 nd->path.dentry = dget_parent(nd->path.dentry); 1096 nd->path.dentry = dget_parent(nd->path.dentry);
1097 dput(old); 1097 dput(old);
1098 break; 1098 break;
1099 } 1099 }
1100 if (!follow_up(&nd->path)) 1100 if (!follow_up(&nd->path))
1101 break; 1101 break;
1102 } 1102 }
1103 follow_mount(&nd->path); 1103 follow_mount(&nd->path);
1104 nd->inode = nd->path.dentry->d_inode; 1104 nd->inode = nd->path.dentry->d_inode;
1105 } 1105 }
1106 1106
1107 /* 1107 /*
1108 * Allocate a dentry with name and parent, and perform a parent 1108 * Allocate a dentry with name and parent, and perform a parent
1109 * directory ->lookup on it. Returns the new dentry, or ERR_PTR 1109 * directory ->lookup on it. Returns the new dentry, or ERR_PTR
1110 * on error. parent->d_inode->i_mutex must be held. d_lookup must 1110 * on error. parent->d_inode->i_mutex must be held. d_lookup must
1111 * have verified that no child exists while under i_mutex. 1111 * have verified that no child exists while under i_mutex.
1112 */ 1112 */
1113 static struct dentry *d_alloc_and_lookup(struct dentry *parent, 1113 static struct dentry *d_alloc_and_lookup(struct dentry *parent,
1114 struct qstr *name, struct nameidata *nd) 1114 struct qstr *name, struct nameidata *nd)
1115 { 1115 {
1116 struct inode *inode = parent->d_inode; 1116 struct inode *inode = parent->d_inode;
1117 struct dentry *dentry; 1117 struct dentry *dentry;
1118 struct dentry *old; 1118 struct dentry *old;
1119 1119
1120 /* Don't create child dentry for a dead directory. */ 1120 /* Don't create child dentry for a dead directory. */
1121 if (unlikely(IS_DEADDIR(inode))) 1121 if (unlikely(IS_DEADDIR(inode)))
1122 return ERR_PTR(-ENOENT); 1122 return ERR_PTR(-ENOENT);
1123 1123
1124 dentry = d_alloc(parent, name); 1124 dentry = d_alloc(parent, name);
1125 if (unlikely(!dentry)) 1125 if (unlikely(!dentry))
1126 return ERR_PTR(-ENOMEM); 1126 return ERR_PTR(-ENOMEM);
1127 1127
1128 old = inode->i_op->lookup(inode, dentry, nd); 1128 old = inode->i_op->lookup(inode, dentry, nd);
1129 if (unlikely(old)) { 1129 if (unlikely(old)) {
1130 dput(dentry); 1130 dput(dentry);
1131 dentry = old; 1131 dentry = old;
1132 } 1132 }
1133 return dentry; 1133 return dentry;
1134 } 1134 }
1135 1135
1136 /* 1136 /*
1137 * We already have a dentry, but require a lookup to be performed on the parent 1137 * We already have a dentry, but require a lookup to be performed on the parent
1138 * directory to fill in d_inode. Returns the new dentry, or ERR_PTR on error. 1138 * directory to fill in d_inode. Returns the new dentry, or ERR_PTR on error.
1139 * parent->d_inode->i_mutex must be held. d_lookup must have verified that no 1139 * parent->d_inode->i_mutex must be held. d_lookup must have verified that no
1140 * child exists while under i_mutex. 1140 * child exists while under i_mutex.
1141 */ 1141 */
1142 static struct dentry *d_inode_lookup(struct dentry *parent, struct dentry *dentry, 1142 static struct dentry *d_inode_lookup(struct dentry *parent, struct dentry *dentry,
1143 struct nameidata *nd) 1143 struct nameidata *nd)
1144 { 1144 {
1145 struct inode *inode = parent->d_inode; 1145 struct inode *inode = parent->d_inode;
1146 struct dentry *old; 1146 struct dentry *old;
1147 1147
1148 /* Don't create child dentry for a dead directory. */ 1148 /* Don't create child dentry for a dead directory. */
1149 if (unlikely(IS_DEADDIR(inode))) 1149 if (unlikely(IS_DEADDIR(inode)))
1150 return ERR_PTR(-ENOENT); 1150 return ERR_PTR(-ENOENT);
1151 1151
1152 old = inode->i_op->lookup(inode, dentry, nd); 1152 old = inode->i_op->lookup(inode, dentry, nd);
1153 if (unlikely(old)) { 1153 if (unlikely(old)) {
1154 dput(dentry); 1154 dput(dentry);
1155 dentry = old; 1155 dentry = old;
1156 } 1156 }
1157 return dentry; 1157 return dentry;
1158 } 1158 }
1159 1159
1160 /* 1160 /*
1161 * It's more convoluted than I'd like it to be, but... it's still fairly 1161 * It's more convoluted than I'd like it to be, but... it's still fairly
1162 * small and for now I'd prefer to have fast path as straight as possible. 1162 * small and for now I'd prefer to have fast path as straight as possible.
1163 * It _is_ time-critical. 1163 * It _is_ time-critical.
1164 */ 1164 */
1165 static int do_lookup(struct nameidata *nd, struct qstr *name, 1165 static int do_lookup(struct nameidata *nd, struct qstr *name,
1166 struct path *path, struct inode **inode) 1166 struct path *path, struct inode **inode)
1167 { 1167 {
1168 struct vfsmount *mnt = nd->path.mnt; 1168 struct vfsmount *mnt = nd->path.mnt;
1169 struct dentry *dentry, *parent = nd->path.dentry; 1169 struct dentry *dentry, *parent = nd->path.dentry;
1170 int need_reval = 1; 1170 int need_reval = 1;
1171 int status = 1; 1171 int status = 1;
1172 int err; 1172 int err;
1173 1173
1174 /* 1174 /*
1175 * Rename seqlock is not required here because in the off chance 1175 * Rename seqlock is not required here because in the off chance
1176 * of a false negative due to a concurrent rename, we're going to 1176 * of a false negative due to a concurrent rename, we're going to
1177 * do the non-racy lookup, below. 1177 * do the non-racy lookup, below.
1178 */ 1178 */
1179 if (nd->flags & LOOKUP_RCU) { 1179 if (nd->flags & LOOKUP_RCU) {
1180 unsigned seq; 1180 unsigned seq;
1181 *inode = nd->inode; 1181 *inode = nd->inode;
1182 dentry = __d_lookup_rcu(parent, name, &seq, inode); 1182 dentry = __d_lookup_rcu(parent, name, &seq, inode);
1183 if (!dentry) 1183 if (!dentry)
1184 goto unlazy; 1184 goto unlazy;
1185 1185
1186 /* Memory barrier in read_seqcount_begin of child is enough */ 1186 /* Memory barrier in read_seqcount_begin of child is enough */
1187 if (__read_seqcount_retry(&parent->d_seq, nd->seq)) 1187 if (__read_seqcount_retry(&parent->d_seq, nd->seq))
1188 return -ECHILD; 1188 return -ECHILD;
1189 nd->seq = seq; 1189 nd->seq = seq;
1190 1190
1191 if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE)) { 1191 if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE)) {
1192 status = d_revalidate(dentry, nd); 1192 status = d_revalidate(dentry, nd);
1193 if (unlikely(status <= 0)) { 1193 if (unlikely(status <= 0)) {
1194 if (status != -ECHILD) 1194 if (status != -ECHILD)
1195 need_reval = 0; 1195 need_reval = 0;
1196 goto unlazy; 1196 goto unlazy;
1197 } 1197 }
1198 } 1198 }
1199 if (unlikely(d_need_lookup(dentry))) 1199 if (unlikely(d_need_lookup(dentry)))
1200 goto unlazy; 1200 goto unlazy;
1201 path->mnt = mnt; 1201 path->mnt = mnt;
1202 path->dentry = dentry; 1202 path->dentry = dentry;
1203 if (unlikely(!__follow_mount_rcu(nd, path, inode))) 1203 if (unlikely(!__follow_mount_rcu(nd, path, inode)))
1204 goto unlazy; 1204 goto unlazy;
1205 if (unlikely(path->dentry->d_flags & DCACHE_NEED_AUTOMOUNT)) 1205 if (unlikely(path->dentry->d_flags & DCACHE_NEED_AUTOMOUNT))
1206 goto unlazy; 1206 goto unlazy;
1207 return 0; 1207 return 0;
1208 unlazy: 1208 unlazy:
1209 if (unlazy_walk(nd, dentry)) 1209 if (unlazy_walk(nd, dentry))
1210 return -ECHILD; 1210 return -ECHILD;
1211 } else { 1211 } else {
1212 dentry = __d_lookup(parent, name); 1212 dentry = __d_lookup(parent, name);
1213 } 1213 }
1214 1214
1215 if (dentry && unlikely(d_need_lookup(dentry))) { 1215 if (dentry && unlikely(d_need_lookup(dentry))) {
1216 dput(dentry); 1216 dput(dentry);
1217 dentry = NULL; 1217 dentry = NULL;
1218 } 1218 }
1219 retry: 1219 retry:
1220 if (unlikely(!dentry)) { 1220 if (unlikely(!dentry)) {
1221 struct inode *dir = parent->d_inode; 1221 struct inode *dir = parent->d_inode;
1222 BUG_ON(nd->inode != dir); 1222 BUG_ON(nd->inode != dir);
1223 1223
1224 mutex_lock(&dir->i_mutex); 1224 mutex_lock(&dir->i_mutex);
1225 dentry = d_lookup(parent, name); 1225 dentry = d_lookup(parent, name);
1226 if (likely(!dentry)) { 1226 if (likely(!dentry)) {
1227 dentry = d_alloc_and_lookup(parent, name, nd); 1227 dentry = d_alloc_and_lookup(parent, name, nd);
1228 if (IS_ERR(dentry)) { 1228 if (IS_ERR(dentry)) {
1229 mutex_unlock(&dir->i_mutex); 1229 mutex_unlock(&dir->i_mutex);
1230 return PTR_ERR(dentry); 1230 return PTR_ERR(dentry);
1231 } 1231 }
1232 /* known good */ 1232 /* known good */
1233 need_reval = 0; 1233 need_reval = 0;
1234 status = 1; 1234 status = 1;
1235 } else if (unlikely(d_need_lookup(dentry))) { 1235 } else if (unlikely(d_need_lookup(dentry))) {
1236 dentry = d_inode_lookup(parent, dentry, nd); 1236 dentry = d_inode_lookup(parent, dentry, nd);
1237 if (IS_ERR(dentry)) { 1237 if (IS_ERR(dentry)) {
1238 mutex_unlock(&dir->i_mutex); 1238 mutex_unlock(&dir->i_mutex);
1239 return PTR_ERR(dentry); 1239 return PTR_ERR(dentry);
1240 } 1240 }
1241 /* known good */ 1241 /* known good */
1242 need_reval = 0; 1242 need_reval = 0;
1243 status = 1; 1243 status = 1;
1244 } 1244 }
1245 mutex_unlock(&dir->i_mutex); 1245 mutex_unlock(&dir->i_mutex);
1246 } 1246 }
1247 if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE) && need_reval) 1247 if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE) && need_reval)
1248 status = d_revalidate(dentry, nd); 1248 status = d_revalidate(dentry, nd);
1249 if (unlikely(status <= 0)) { 1249 if (unlikely(status <= 0)) {
1250 if (status < 0) { 1250 if (status < 0) {
1251 dput(dentry); 1251 dput(dentry);
1252 return status; 1252 return status;
1253 } 1253 }
1254 if (!d_invalidate(dentry)) { 1254 if (!d_invalidate(dentry)) {
1255 dput(dentry); 1255 dput(dentry);
1256 dentry = NULL; 1256 dentry = NULL;
1257 need_reval = 1; 1257 need_reval = 1;
1258 goto retry; 1258 goto retry;
1259 } 1259 }
1260 } 1260 }
1261 1261
1262 path->mnt = mnt; 1262 path->mnt = mnt;
1263 path->dentry = dentry; 1263 path->dentry = dentry;
1264 err = follow_managed(path, nd->flags); 1264 err = follow_managed(path, nd->flags);
1265 if (unlikely(err < 0)) { 1265 if (unlikely(err < 0)) {
1266 path_put_conditional(path, nd); 1266 path_put_conditional(path, nd);
1267 return err; 1267 return err;
1268 } 1268 }
1269 *inode = path->dentry->d_inode; 1269 *inode = path->dentry->d_inode;
1270 return 0; 1270 return 0;
1271 } 1271 }
1272 1272
1273 static inline int may_lookup(struct nameidata *nd) 1273 static inline int may_lookup(struct nameidata *nd)
1274 { 1274 {
1275 if (nd->flags & LOOKUP_RCU) { 1275 if (nd->flags & LOOKUP_RCU) {
1276 int err = exec_permission(nd->inode, IPERM_FLAG_RCU); 1276 int err = exec_permission(nd->inode, IPERM_FLAG_RCU);
1277 if (err != -ECHILD) 1277 if (err != -ECHILD)
1278 return err; 1278 return err;
1279 if (unlazy_walk(nd, NULL)) 1279 if (unlazy_walk(nd, NULL))
1280 return -ECHILD; 1280 return -ECHILD;
1281 } 1281 }
1282 return exec_permission(nd->inode, 0); 1282 return exec_permission(nd->inode, 0);
1283 } 1283 }
1284 1284
1285 static inline int handle_dots(struct nameidata *nd, int type) 1285 static inline int handle_dots(struct nameidata *nd, int type)
1286 { 1286 {
1287 if (type == LAST_DOTDOT) { 1287 if (type == LAST_DOTDOT) {
1288 if (nd->flags & LOOKUP_RCU) { 1288 if (nd->flags & LOOKUP_RCU) {
1289 if (follow_dotdot_rcu(nd)) 1289 if (follow_dotdot_rcu(nd))
1290 return -ECHILD; 1290 return -ECHILD;
1291 } else 1291 } else
1292 follow_dotdot(nd); 1292 follow_dotdot(nd);
1293 } 1293 }
1294 return 0; 1294 return 0;
1295 } 1295 }
1296 1296
1297 static void terminate_walk(struct nameidata *nd) 1297 static void terminate_walk(struct nameidata *nd)
1298 { 1298 {
1299 if (!(nd->flags & LOOKUP_RCU)) { 1299 if (!(nd->flags & LOOKUP_RCU)) {
1300 path_put(&nd->path); 1300 path_put(&nd->path);
1301 } else { 1301 } else {
1302 nd->flags &= ~LOOKUP_RCU; 1302 nd->flags &= ~LOOKUP_RCU;
1303 if (!(nd->flags & LOOKUP_ROOT)) 1303 if (!(nd->flags & LOOKUP_ROOT))
1304 nd->root.mnt = NULL; 1304 nd->root.mnt = NULL;
1305 rcu_read_unlock(); 1305 rcu_read_unlock();
1306 br_read_unlock(vfsmount_lock); 1306 br_read_unlock(vfsmount_lock);
1307 } 1307 }
1308 } 1308 }
1309 1309
1310 static inline int walk_component(struct nameidata *nd, struct path *path, 1310 static inline int walk_component(struct nameidata *nd, struct path *path,
1311 struct qstr *name, int type, int follow) 1311 struct qstr *name, int type, int follow)
1312 { 1312 {
1313 struct inode *inode; 1313 struct inode *inode;
1314 int err; 1314 int err;
1315 /* 1315 /*
1316 * "." and ".." are special - ".." especially so because it has 1316 * "." and ".." are special - ".." especially so because it has
1317 * to be able to know about the current root directory and 1317 * to be able to know about the current root directory and
1318 * parent relationships. 1318 * parent relationships.
1319 */ 1319 */
1320 if (unlikely(type != LAST_NORM)) 1320 if (unlikely(type != LAST_NORM))
1321 return handle_dots(nd, type); 1321 return handle_dots(nd, type);
1322 err = do_lookup(nd, name, path, &inode); 1322 err = do_lookup(nd, name, path, &inode);
1323 if (unlikely(err)) { 1323 if (unlikely(err)) {
1324 terminate_walk(nd); 1324 terminate_walk(nd);
1325 return err; 1325 return err;
1326 } 1326 }
1327 if (!inode) { 1327 if (!inode) {
1328 path_to_nameidata(path, nd); 1328 path_to_nameidata(path, nd);
1329 terminate_walk(nd); 1329 terminate_walk(nd);
1330 return -ENOENT; 1330 return -ENOENT;
1331 } 1331 }
1332 if (unlikely(inode->i_op->follow_link) && follow) { 1332 if (unlikely(inode->i_op->follow_link) && follow) {
1333 if (nd->flags & LOOKUP_RCU) { 1333 if (nd->flags & LOOKUP_RCU) {
1334 if (unlikely(unlazy_walk(nd, path->dentry))) { 1334 if (unlikely(unlazy_walk(nd, path->dentry))) {
1335 terminate_walk(nd); 1335 terminate_walk(nd);
1336 return -ECHILD; 1336 return -ECHILD;
1337 } 1337 }
1338 } 1338 }
1339 BUG_ON(inode != path->dentry->d_inode); 1339 BUG_ON(inode != path->dentry->d_inode);
1340 return 1; 1340 return 1;
1341 } 1341 }
1342 path_to_nameidata(path, nd); 1342 path_to_nameidata(path, nd);
1343 nd->inode = inode; 1343 nd->inode = inode;
1344 return 0; 1344 return 0;
1345 } 1345 }
1346 1346
1347 /* 1347 /*
1348 * This limits recursive symlink follows to 8, while 1348 * This limits recursive symlink follows to 8, while
1349 * limiting consecutive symlinks to 40. 1349 * limiting consecutive symlinks to 40.
1350 * 1350 *
1351 * Without that kind of total limit, nasty chains of consecutive 1351 * Without that kind of total limit, nasty chains of consecutive
1352 * symlinks can cause almost arbitrarily long lookups. 1352 * symlinks can cause almost arbitrarily long lookups.
1353 */ 1353 */
1354 static inline int nested_symlink(struct path *path, struct nameidata *nd) 1354 static inline int nested_symlink(struct path *path, struct nameidata *nd)
1355 { 1355 {
1356 int res; 1356 int res;
1357 1357
1358 if (unlikely(current->link_count >= MAX_NESTED_LINKS)) { 1358 if (unlikely(current->link_count >= MAX_NESTED_LINKS)) {
1359 path_put_conditional(path, nd); 1359 path_put_conditional(path, nd);
1360 path_put(&nd->path); 1360 path_put(&nd->path);
1361 return -ELOOP; 1361 return -ELOOP;
1362 } 1362 }
1363 BUG_ON(nd->depth >= MAX_NESTED_LINKS); 1363 BUG_ON(nd->depth >= MAX_NESTED_LINKS);
1364 1364
1365 nd->depth++; 1365 nd->depth++;
1366 current->link_count++; 1366 current->link_count++;
1367 1367
1368 do { 1368 do {
1369 struct path link = *path; 1369 struct path link = *path;
1370 void *cookie; 1370 void *cookie;
1371 1371
1372 res = follow_link(&link, nd, &cookie); 1372 res = follow_link(&link, nd, &cookie);
1373 if (!res) 1373 if (!res)
1374 res = walk_component(nd, path, &nd->last, 1374 res = walk_component(nd, path, &nd->last,
1375 nd->last_type, LOOKUP_FOLLOW); 1375 nd->last_type, LOOKUP_FOLLOW);
1376 put_link(nd, &link, cookie); 1376 put_link(nd, &link, cookie);
1377 } while (res > 0); 1377 } while (res > 0);
1378 1378
1379 current->link_count--; 1379 current->link_count--;
1380 nd->depth--; 1380 nd->depth--;
1381 return res; 1381 return res;
1382 } 1382 }
1383 1383
1384 /* 1384 /*
1385 * Name resolution. 1385 * Name resolution.
1386 * This is the basic name resolution function, turning a pathname into 1386 * This is the basic name resolution function, turning a pathname into
1387 * the final dentry. We expect 'base' to be positive and a directory. 1387 * the final dentry. We expect 'base' to be positive and a directory.
1388 * 1388 *
1389 * Returns 0 and nd will have valid dentry and mnt on success. 1389 * Returns 0 and nd will have valid dentry and mnt on success.
1390 * Returns error and drops reference to input namei data on failure. 1390 * Returns error and drops reference to input namei data on failure.
1391 */ 1391 */
1392 static int link_path_walk(const char *name, struct nameidata *nd) 1392 static int link_path_walk(const char *name, struct nameidata *nd)
1393 { 1393 {
1394 struct path next; 1394 struct path next;
1395 int err; 1395 int err;
1396 unsigned int lookup_flags = nd->flags; 1396 unsigned int lookup_flags = nd->flags;
1397 1397
1398 while (*name=='/') 1398 while (*name=='/')
1399 name++; 1399 name++;
1400 if (!*name) 1400 if (!*name)
1401 return 0; 1401 return 0;
1402 1402
1403 /* At this point we know we have a real path component. */ 1403 /* At this point we know we have a real path component. */
1404 for(;;) { 1404 for(;;) {
1405 unsigned long hash; 1405 unsigned long hash;
1406 struct qstr this; 1406 struct qstr this;
1407 unsigned int c; 1407 unsigned int c;
1408 int type; 1408 int type;
1409 1409
1410 nd->flags |= LOOKUP_CONTINUE; 1410 nd->flags |= LOOKUP_CONTINUE;
1411 1411
1412 err = may_lookup(nd); 1412 err = may_lookup(nd);
1413 if (err) 1413 if (err)
1414 break; 1414 break;
1415 1415
1416 this.name = name; 1416 this.name = name;
1417 c = *(const unsigned char *)name; 1417 c = *(const unsigned char *)name;
1418 1418
1419 hash = init_name_hash(); 1419 hash = init_name_hash();
1420 do { 1420 do {
1421 name++; 1421 name++;
1422 hash = partial_name_hash(c, hash); 1422 hash = partial_name_hash(c, hash);
1423 c = *(const unsigned char *)name; 1423 c = *(const unsigned char *)name;
1424 } while (c && (c != '/')); 1424 } while (c && (c != '/'));
1425 this.len = name - (const char *) this.name; 1425 this.len = name - (const char *) this.name;
1426 this.hash = end_name_hash(hash); 1426 this.hash = end_name_hash(hash);
1427 1427
1428 type = LAST_NORM; 1428 type = LAST_NORM;
1429 if (this.name[0] == '.') switch (this.len) { 1429 if (this.name[0] == '.') switch (this.len) {
1430 case 2: 1430 case 2:
1431 if (this.name[1] == '.') { 1431 if (this.name[1] == '.') {
1432 type = LAST_DOTDOT; 1432 type = LAST_DOTDOT;
1433 nd->flags |= LOOKUP_JUMPED; 1433 nd->flags |= LOOKUP_JUMPED;
1434 } 1434 }
1435 break; 1435 break;
1436 case 1: 1436 case 1:
1437 type = LAST_DOT; 1437 type = LAST_DOT;
1438 } 1438 }
1439 if (likely(type == LAST_NORM)) { 1439 if (likely(type == LAST_NORM)) {
1440 struct dentry *parent = nd->path.dentry; 1440 struct dentry *parent = nd->path.dentry;
1441 nd->flags &= ~LOOKUP_JUMPED; 1441 nd->flags &= ~LOOKUP_JUMPED;
1442 if (unlikely(parent->d_flags & DCACHE_OP_HASH)) { 1442 if (unlikely(parent->d_flags & DCACHE_OP_HASH)) {
1443 err = parent->d_op->d_hash(parent, nd->inode, 1443 err = parent->d_op->d_hash(parent, nd->inode,
1444 &this); 1444 &this);
1445 if (err < 0) 1445 if (err < 0)
1446 break; 1446 break;
1447 } 1447 }
1448 } 1448 }
1449 1449
1450 /* remove trailing slashes? */ 1450 /* remove trailing slashes? */
1451 if (!c) 1451 if (!c)
1452 goto last_component; 1452 goto last_component;
1453 while (*++name == '/'); 1453 while (*++name == '/');
1454 if (!*name) 1454 if (!*name)
1455 goto last_component; 1455 goto last_component;
1456 1456
1457 err = walk_component(nd, &next, &this, type, LOOKUP_FOLLOW); 1457 err = walk_component(nd, &next, &this, type, LOOKUP_FOLLOW);
1458 if (err < 0) 1458 if (err < 0)
1459 return err; 1459 return err;
1460 1460
1461 if (err) { 1461 if (err) {
1462 err = nested_symlink(&next, nd); 1462 err = nested_symlink(&next, nd);
1463 if (err) 1463 if (err)
1464 return err; 1464 return err;
1465 } 1465 }
1466 err = -ENOTDIR; 1466 err = -ENOTDIR;
1467 if (!nd->inode->i_op->lookup) 1467 if (!nd->inode->i_op->lookup)
1468 break; 1468 break;
1469 continue; 1469 continue;
1470 /* here ends the main loop */ 1470 /* here ends the main loop */
1471 1471
1472 last_component: 1472 last_component:
1473 /* Clear LOOKUP_CONTINUE iff it was previously unset */ 1473 /* Clear LOOKUP_CONTINUE iff it was previously unset */
1474 nd->flags &= lookup_flags | ~LOOKUP_CONTINUE; 1474 nd->flags &= lookup_flags | ~LOOKUP_CONTINUE;
1475 nd->last = this; 1475 nd->last = this;
1476 nd->last_type = type; 1476 nd->last_type = type;
1477 return 0; 1477 return 0;
1478 } 1478 }
1479 terminate_walk(nd); 1479 terminate_walk(nd);
1480 return err; 1480 return err;
1481 } 1481 }
1482 1482
1483 static int path_init(int dfd, const char *name, unsigned int flags, 1483 static int path_init(int dfd, const char *name, unsigned int flags,
1484 struct nameidata *nd, struct file **fp) 1484 struct nameidata *nd, struct file **fp)
1485 { 1485 {
1486 int retval = 0; 1486 int retval = 0;
1487 int fput_needed; 1487 int fput_needed;
1488 struct file *file; 1488 struct file *file;
1489 1489
1490 nd->last_type = LAST_ROOT; /* if there are only slashes... */ 1490 nd->last_type = LAST_ROOT; /* if there are only slashes... */
1491 nd->flags = flags | LOOKUP_JUMPED; 1491 nd->flags = flags | LOOKUP_JUMPED;
1492 nd->depth = 0; 1492 nd->depth = 0;
1493 if (flags & LOOKUP_ROOT) { 1493 if (flags & LOOKUP_ROOT) {
1494 struct inode *inode = nd->root.dentry->d_inode; 1494 struct inode *inode = nd->root.dentry->d_inode;
1495 if (*name) { 1495 if (*name) {
1496 if (!inode->i_op->lookup) 1496 if (!inode->i_op->lookup)
1497 return -ENOTDIR; 1497 return -ENOTDIR;
1498 retval = inode_permission(inode, MAY_EXEC); 1498 retval = inode_permission(inode, MAY_EXEC);
1499 if (retval) 1499 if (retval)
1500 return retval; 1500 return retval;
1501 } 1501 }
1502 nd->path = nd->root; 1502 nd->path = nd->root;
1503 nd->inode = inode; 1503 nd->inode = inode;
1504 if (flags & LOOKUP_RCU) { 1504 if (flags & LOOKUP_RCU) {
1505 br_read_lock(vfsmount_lock); 1505 br_read_lock(vfsmount_lock);
1506 rcu_read_lock(); 1506 rcu_read_lock();
1507 nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq); 1507 nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
1508 } else { 1508 } else {
1509 path_get(&nd->path); 1509 path_get(&nd->path);
1510 } 1510 }
1511 return 0; 1511 return 0;
1512 } 1512 }
1513 1513
1514 nd->root.mnt = NULL; 1514 nd->root.mnt = NULL;
1515 1515
1516 if (*name=='/') { 1516 if (*name=='/') {
1517 if (flags & LOOKUP_RCU) { 1517 if (flags & LOOKUP_RCU) {
1518 br_read_lock(vfsmount_lock); 1518 br_read_lock(vfsmount_lock);
1519 rcu_read_lock(); 1519 rcu_read_lock();
1520 set_root_rcu(nd); 1520 set_root_rcu(nd);
1521 } else { 1521 } else {
1522 set_root(nd); 1522 set_root(nd);
1523 path_get(&nd->root); 1523 path_get(&nd->root);
1524 } 1524 }
1525 nd->path = nd->root; 1525 nd->path = nd->root;
1526 } else if (dfd == AT_FDCWD) { 1526 } else if (dfd == AT_FDCWD) {
1527 if (flags & LOOKUP_RCU) { 1527 if (flags & LOOKUP_RCU) {
1528 struct fs_struct *fs = current->fs; 1528 struct fs_struct *fs = current->fs;
1529 unsigned seq; 1529 unsigned seq;
1530 1530
1531 br_read_lock(vfsmount_lock); 1531 br_read_lock(vfsmount_lock);
1532 rcu_read_lock(); 1532 rcu_read_lock();
1533 1533
1534 do { 1534 do {
1535 seq = read_seqcount_begin(&fs->seq); 1535 seq = read_seqcount_begin(&fs->seq);
1536 nd->path = fs->pwd; 1536 nd->path = fs->pwd;
1537 nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq); 1537 nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
1538 } while (read_seqcount_retry(&fs->seq, seq)); 1538 } while (read_seqcount_retry(&fs->seq, seq));
1539 } else { 1539 } else {
1540 get_fs_pwd(current->fs, &nd->path); 1540 get_fs_pwd(current->fs, &nd->path);
1541 } 1541 }
1542 } else { 1542 } else {
1543 struct dentry *dentry; 1543 struct dentry *dentry;
1544 1544
1545 file = fget_raw_light(dfd, &fput_needed); 1545 file = fget_raw_light(dfd, &fput_needed);
1546 retval = -EBADF; 1546 retval = -EBADF;
1547 if (!file) 1547 if (!file)
1548 goto out_fail; 1548 goto out_fail;
1549 1549
1550 dentry = file->f_path.dentry; 1550 dentry = file->f_path.dentry;
1551 1551
1552 if (*name) { 1552 if (*name) {
1553 retval = -ENOTDIR; 1553 retval = -ENOTDIR;
1554 if (!S_ISDIR(dentry->d_inode->i_mode)) 1554 if (!S_ISDIR(dentry->d_inode->i_mode))
1555 goto fput_fail; 1555 goto fput_fail;
1556 1556
1557 retval = file_permission(file, MAY_EXEC); 1557 retval = file_permission(file, MAY_EXEC);
1558 if (retval) 1558 if (retval)
1559 goto fput_fail; 1559 goto fput_fail;
1560 } 1560 }
1561 1561
1562 nd->path = file->f_path; 1562 nd->path = file->f_path;
1563 if (flags & LOOKUP_RCU) { 1563 if (flags & LOOKUP_RCU) {
1564 if (fput_needed) 1564 if (fput_needed)
1565 *fp = file; 1565 *fp = file;
1566 nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq); 1566 nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
1567 br_read_lock(vfsmount_lock); 1567 br_read_lock(vfsmount_lock);
1568 rcu_read_lock(); 1568 rcu_read_lock();
1569 } else { 1569 } else {
1570 path_get(&file->f_path); 1570 path_get(&file->f_path);
1571 fput_light(file, fput_needed); 1571 fput_light(file, fput_needed);
1572 } 1572 }
1573 } 1573 }
1574 1574
1575 nd->inode = nd->path.dentry->d_inode; 1575 nd->inode = nd->path.dentry->d_inode;
1576 return 0; 1576 return 0;
1577 1577
1578 fput_fail: 1578 fput_fail:
1579 fput_light(file, fput_needed); 1579 fput_light(file, fput_needed);
1580 out_fail: 1580 out_fail:
1581 return retval; 1581 return retval;
1582 } 1582 }
1583 1583
1584 static inline int lookup_last(struct nameidata *nd, struct path *path) 1584 static inline int lookup_last(struct nameidata *nd, struct path *path)
1585 { 1585 {
1586 if (nd->last_type == LAST_NORM && nd->last.name[nd->last.len]) 1586 if (nd->last_type == LAST_NORM && nd->last.name[nd->last.len])
1587 nd->flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY; 1587 nd->flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
1588 1588
1589 nd->flags &= ~LOOKUP_PARENT; 1589 nd->flags &= ~LOOKUP_PARENT;
1590 return walk_component(nd, path, &nd->last, nd->last_type, 1590 return walk_component(nd, path, &nd->last, nd->last_type,
1591 nd->flags & LOOKUP_FOLLOW); 1591 nd->flags & LOOKUP_FOLLOW);
1592 } 1592 }
1593 1593
1594 /* Returns 0 and nd will be valid on success; Retuns error, otherwise. */ 1594 /* Returns 0 and nd will be valid on success; Retuns error, otherwise. */
1595 static int path_lookupat(int dfd, const char *name, 1595 static int path_lookupat(int dfd, const char *name,
1596 unsigned int flags, struct nameidata *nd) 1596 unsigned int flags, struct nameidata *nd)
1597 { 1597 {
1598 struct file *base = NULL; 1598 struct file *base = NULL;
1599 struct path path; 1599 struct path path;
1600 int err; 1600 int err;
1601 1601
1602 /* 1602 /*
1603 * Path walking is largely split up into 2 different synchronisation 1603 * Path walking is largely split up into 2 different synchronisation
1604 * schemes, rcu-walk and ref-walk (explained in 1604 * schemes, rcu-walk and ref-walk (explained in
1605 * Documentation/filesystems/path-lookup.txt). These share much of the 1605 * Documentation/filesystems/path-lookup.txt). These share much of the
1606 * path walk code, but some things particularly setup, cleanup, and 1606 * path walk code, but some things particularly setup, cleanup, and
1607 * following mounts are sufficiently divergent that functions are 1607 * following mounts are sufficiently divergent that functions are
1608 * duplicated. Typically there is a function foo(), and its RCU 1608 * duplicated. Typically there is a function foo(), and its RCU
1609 * analogue, foo_rcu(). 1609 * analogue, foo_rcu().
1610 * 1610 *
1611 * -ECHILD is the error number of choice (just to avoid clashes) that 1611 * -ECHILD is the error number of choice (just to avoid clashes) that
1612 * is returned if some aspect of an rcu-walk fails. Such an error must 1612 * is returned if some aspect of an rcu-walk fails. Such an error must
1613 * be handled by restarting a traditional ref-walk (which will always 1613 * be handled by restarting a traditional ref-walk (which will always
1614 * be able to complete). 1614 * be able to complete).
1615 */ 1615 */
1616 err = path_init(dfd, name, flags | LOOKUP_PARENT, nd, &base); 1616 err = path_init(dfd, name, flags | LOOKUP_PARENT, nd, &base);
1617 1617
1618 if (unlikely(err)) 1618 if (unlikely(err))
1619 return err; 1619 return err;
1620 1620
1621 current->total_link_count = 0; 1621 current->total_link_count = 0;
1622 err = link_path_walk(name, nd); 1622 err = link_path_walk(name, nd);
1623 1623
1624 if (!err && !(flags & LOOKUP_PARENT)) { 1624 if (!err && !(flags & LOOKUP_PARENT)) {
1625 err = lookup_last(nd, &path); 1625 err = lookup_last(nd, &path);
1626 while (err > 0) { 1626 while (err > 0) {
1627 void *cookie; 1627 void *cookie;
1628 struct path link = path; 1628 struct path link = path;
1629 nd->flags |= LOOKUP_PARENT; 1629 nd->flags |= LOOKUP_PARENT;
1630 err = follow_link(&link, nd, &cookie); 1630 err = follow_link(&link, nd, &cookie);
1631 if (!err) 1631 if (!err)
1632 err = lookup_last(nd, &path); 1632 err = lookup_last(nd, &path);
1633 put_link(nd, &link, cookie); 1633 put_link(nd, &link, cookie);
1634 } 1634 }
1635 } 1635 }
1636 1636
1637 if (!err) 1637 if (!err)
1638 err = complete_walk(nd); 1638 err = complete_walk(nd);
1639 1639
1640 if (!err && nd->flags & LOOKUP_DIRECTORY) { 1640 if (!err && nd->flags & LOOKUP_DIRECTORY) {
1641 if (!nd->inode->i_op->lookup) { 1641 if (!nd->inode->i_op->lookup) {
1642 path_put(&nd->path); 1642 path_put(&nd->path);
1643 err = -ENOTDIR; 1643 err = -ENOTDIR;
1644 } 1644 }
1645 } 1645 }
1646 1646
1647 if (base) 1647 if (base)
1648 fput(base); 1648 fput(base);
1649 1649
1650 if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT)) { 1650 if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT)) {
1651 path_put(&nd->root); 1651 path_put(&nd->root);
1652 nd->root.mnt = NULL; 1652 nd->root.mnt = NULL;
1653 } 1653 }
1654 return err; 1654 return err;
1655 } 1655 }
1656 1656
1657 static int do_path_lookup(int dfd, const char *name, 1657 static int do_path_lookup(int dfd, const char *name,
1658 unsigned int flags, struct nameidata *nd) 1658 unsigned int flags, struct nameidata *nd)
1659 { 1659 {
1660 int retval = path_lookupat(dfd, name, flags | LOOKUP_RCU, nd); 1660 int retval = path_lookupat(dfd, name, flags | LOOKUP_RCU, nd);
1661 if (unlikely(retval == -ECHILD)) 1661 if (unlikely(retval == -ECHILD))
1662 retval = path_lookupat(dfd, name, flags, nd); 1662 retval = path_lookupat(dfd, name, flags, nd);
1663 if (unlikely(retval == -ESTALE)) 1663 if (unlikely(retval == -ESTALE))
1664 retval = path_lookupat(dfd, name, flags | LOOKUP_REVAL, nd); 1664 retval = path_lookupat(dfd, name, flags | LOOKUP_REVAL, nd);
1665 1665
1666 if (likely(!retval)) { 1666 if (likely(!retval)) {
1667 if (unlikely(!audit_dummy_context())) { 1667 if (unlikely(!audit_dummy_context())) {
1668 if (nd->path.dentry && nd->inode) 1668 if (nd->path.dentry && nd->inode)
1669 audit_inode(name, nd->path.dentry); 1669 audit_inode(name, nd->path.dentry);
1670 } 1670 }
1671 } 1671 }
1672 return retval; 1672 return retval;
1673 } 1673 }
1674 1674
1675 int kern_path_parent(const char *name, struct nameidata *nd) 1675 int kern_path_parent(const char *name, struct nameidata *nd)
1676 { 1676 {
1677 return do_path_lookup(AT_FDCWD, name, LOOKUP_PARENT, nd); 1677 return do_path_lookup(AT_FDCWD, name, LOOKUP_PARENT, nd);
1678 } 1678 }
1679 1679
1680 int kern_path(const char *name, unsigned int flags, struct path *path) 1680 int kern_path(const char *name, unsigned int flags, struct path *path)
1681 { 1681 {
1682 struct nameidata nd; 1682 struct nameidata nd;
1683 int res = do_path_lookup(AT_FDCWD, name, flags, &nd); 1683 int res = do_path_lookup(AT_FDCWD, name, flags, &nd);
1684 if (!res) 1684 if (!res)
1685 *path = nd.path; 1685 *path = nd.path;
1686 return res; 1686 return res;
1687 } 1687 }
1688 1688
1689 /** 1689 /**
1690 * vfs_path_lookup - lookup a file path relative to a dentry-vfsmount pair 1690 * vfs_path_lookup - lookup a file path relative to a dentry-vfsmount pair
1691 * @dentry: pointer to dentry of the base directory 1691 * @dentry: pointer to dentry of the base directory
1692 * @mnt: pointer to vfs mount of the base directory 1692 * @mnt: pointer to vfs mount of the base directory
1693 * @name: pointer to file name 1693 * @name: pointer to file name
1694 * @flags: lookup flags 1694 * @flags: lookup flags
1695 * @nd: pointer to nameidata 1695 * @nd: pointer to nameidata
1696 */ 1696 */
1697 int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt, 1697 int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt,
1698 const char *name, unsigned int flags, 1698 const char *name, unsigned int flags,
1699 struct nameidata *nd) 1699 struct nameidata *nd)
1700 { 1700 {
1701 nd->root.dentry = dentry; 1701 nd->root.dentry = dentry;
1702 nd->root.mnt = mnt; 1702 nd->root.mnt = mnt;
1703 /* the first argument of do_path_lookup() is ignored with LOOKUP_ROOT */ 1703 /* the first argument of do_path_lookup() is ignored with LOOKUP_ROOT */
1704 return do_path_lookup(AT_FDCWD, name, flags | LOOKUP_ROOT, nd); 1704 return do_path_lookup(AT_FDCWD, name, flags | LOOKUP_ROOT, nd);
1705 } 1705 }
1706 1706
1707 static struct dentry *__lookup_hash(struct qstr *name, 1707 static struct dentry *__lookup_hash(struct qstr *name,
1708 struct dentry *base, struct nameidata *nd) 1708 struct dentry *base, struct nameidata *nd)
1709 { 1709 {
1710 struct inode *inode = base->d_inode; 1710 struct inode *inode = base->d_inode;
1711 struct dentry *dentry; 1711 struct dentry *dentry;
1712 int err; 1712 int err;
1713 1713
1714 err = exec_permission(inode, 0); 1714 err = exec_permission(inode, 0);
1715 if (err) 1715 if (err)
1716 return ERR_PTR(err); 1716 return ERR_PTR(err);
1717 1717
1718 /* 1718 /*
1719 * Don't bother with __d_lookup: callers are for creat as 1719 * Don't bother with __d_lookup: callers are for creat as
1720 * well as unlink, so a lot of the time it would cost 1720 * well as unlink, so a lot of the time it would cost
1721 * a double lookup. 1721 * a double lookup.
1722 */ 1722 */
1723 dentry = d_lookup(base, name); 1723 dentry = d_lookup(base, name);
1724 1724
1725 if (dentry && d_need_lookup(dentry)) { 1725 if (dentry && d_need_lookup(dentry)) {
1726 /* 1726 /*
1727 * __lookup_hash is called with the parent dir's i_mutex already 1727 * __lookup_hash is called with the parent dir's i_mutex already
1728 * held, so we are good to go here. 1728 * held, so we are good to go here.
1729 */ 1729 */
1730 dentry = d_inode_lookup(base, dentry, nd); 1730 dentry = d_inode_lookup(base, dentry, nd);
1731 if (IS_ERR(dentry)) 1731 if (IS_ERR(dentry))
1732 return dentry; 1732 return dentry;
1733 } 1733 }
1734 1734
1735 if (dentry && (dentry->d_flags & DCACHE_OP_REVALIDATE)) 1735 if (dentry && (dentry->d_flags & DCACHE_OP_REVALIDATE))
1736 dentry = do_revalidate(dentry, nd); 1736 dentry = do_revalidate(dentry, nd);
1737 1737
1738 if (!dentry) 1738 if (!dentry)
1739 dentry = d_alloc_and_lookup(base, name, nd); 1739 dentry = d_alloc_and_lookup(base, name, nd);
1740 1740
1741 return dentry; 1741 return dentry;
1742 } 1742 }
1743 1743
1744 /* 1744 /*
1745 * Restricted form of lookup. Doesn't follow links, single-component only, 1745 * Restricted form of lookup. Doesn't follow links, single-component only,
1746 * needs parent already locked. Doesn't follow mounts. 1746 * needs parent already locked. Doesn't follow mounts.
1747 * SMP-safe. 1747 * SMP-safe.
1748 */ 1748 */
1749 static struct dentry *lookup_hash(struct nameidata *nd) 1749 static struct dentry *lookup_hash(struct nameidata *nd)
1750 { 1750 {
1751 return __lookup_hash(&nd->last, nd->path.dentry, nd); 1751 return __lookup_hash(&nd->last, nd->path.dentry, nd);
1752 } 1752 }
1753 1753
1754 /** 1754 /**
1755 * lookup_one_len - filesystem helper to lookup single pathname component 1755 * lookup_one_len - filesystem helper to lookup single pathname component
1756 * @name: pathname component to lookup 1756 * @name: pathname component to lookup
1757 * @base: base directory to lookup from 1757 * @base: base directory to lookup from
1758 * @len: maximum length @len should be interpreted to 1758 * @len: maximum length @len should be interpreted to
1759 * 1759 *
1760 * Note that this routine is purely a helper for filesystem usage and should 1760 * Note that this routine is purely a helper for filesystem usage and should
1761 * not be called by generic code. Also note that by using this function the 1761 * not be called by generic code. Also note that by using this function the
1762 * nameidata argument is passed to the filesystem methods and a filesystem 1762 * nameidata argument is passed to the filesystem methods and a filesystem
1763 * using this helper needs to be prepared for that. 1763 * using this helper needs to be prepared for that.
1764 */ 1764 */
1765 struct dentry *lookup_one_len(const char *name, struct dentry *base, int len) 1765 struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)
1766 { 1766 {
1767 struct qstr this; 1767 struct qstr this;
1768 unsigned long hash; 1768 unsigned long hash;
1769 unsigned int c; 1769 unsigned int c;
1770 1770
1771 WARN_ON_ONCE(!mutex_is_locked(&base->d_inode->i_mutex)); 1771 WARN_ON_ONCE(!mutex_is_locked(&base->d_inode->i_mutex));
1772 1772
1773 this.name = name; 1773 this.name = name;
1774 this.len = len; 1774 this.len = len;
1775 if (!len) 1775 if (!len)
1776 return ERR_PTR(-EACCES); 1776 return ERR_PTR(-EACCES);
1777 1777
1778 hash = init_name_hash(); 1778 hash = init_name_hash();
1779 while (len--) { 1779 while (len--) {
1780 c = *(const unsigned char *)name++; 1780 c = *(const unsigned char *)name++;
1781 if (c == '/' || c == '\0') 1781 if (c == '/' || c == '\0')
1782 return ERR_PTR(-EACCES); 1782 return ERR_PTR(-EACCES);
1783 hash = partial_name_hash(c, hash); 1783 hash = partial_name_hash(c, hash);
1784 } 1784 }
1785 this.hash = end_name_hash(hash); 1785 this.hash = end_name_hash(hash);
1786 /* 1786 /*
1787 * See if the low-level filesystem might want 1787 * See if the low-level filesystem might want
1788 * to use its own hash.. 1788 * to use its own hash..
1789 */ 1789 */
1790 if (base->d_flags & DCACHE_OP_HASH) { 1790 if (base->d_flags & DCACHE_OP_HASH) {
1791 int err = base->d_op->d_hash(base, base->d_inode, &this); 1791 int err = base->d_op->d_hash(base, base->d_inode, &this);
1792 if (err < 0) 1792 if (err < 0)
1793 return ERR_PTR(err); 1793 return ERR_PTR(err);
1794 } 1794 }
1795 1795
1796 return __lookup_hash(&this, base, NULL); 1796 return __lookup_hash(&this, base, NULL);
1797 } 1797 }
1798 1798
1799 int user_path_at(int dfd, const char __user *name, unsigned flags, 1799 int user_path_at(int dfd, const char __user *name, unsigned flags,
1800 struct path *path) 1800 struct path *path)
1801 { 1801 {
1802 struct nameidata nd; 1802 struct nameidata nd;
1803 char *tmp = getname_flags(name, flags); 1803 char *tmp = getname_flags(name, flags);
1804 int err = PTR_ERR(tmp); 1804 int err = PTR_ERR(tmp);
1805 if (!IS_ERR(tmp)) { 1805 if (!IS_ERR(tmp)) {
1806 1806
1807 BUG_ON(flags & LOOKUP_PARENT); 1807 BUG_ON(flags & LOOKUP_PARENT);
1808 1808
1809 err = do_path_lookup(dfd, tmp, flags, &nd); 1809 err = do_path_lookup(dfd, tmp, flags, &nd);
1810 putname(tmp); 1810 putname(tmp);
1811 if (!err) 1811 if (!err)
1812 *path = nd.path; 1812 *path = nd.path;
1813 } 1813 }
1814 return err; 1814 return err;
1815 } 1815 }
1816 1816
1817 static int user_path_parent(int dfd, const char __user *path, 1817 static int user_path_parent(int dfd, const char __user *path,
1818 struct nameidata *nd, char **name) 1818 struct nameidata *nd, char **name)
1819 { 1819 {
1820 char *s = getname(path); 1820 char *s = getname(path);
1821 int error; 1821 int error;
1822 1822
1823 if (IS_ERR(s)) 1823 if (IS_ERR(s))
1824 return PTR_ERR(s); 1824 return PTR_ERR(s);
1825 1825
1826 error = do_path_lookup(dfd, s, LOOKUP_PARENT, nd); 1826 error = do_path_lookup(dfd, s, LOOKUP_PARENT, nd);
1827 if (error) 1827 if (error)
1828 putname(s); 1828 putname(s);
1829 else 1829 else
1830 *name = s; 1830 *name = s;
1831 1831
1832 return error; 1832 return error;
1833 } 1833 }
1834 1834
1835 /* 1835 /*
1836 * It's inline, so penalty for filesystems that don't use sticky bit is 1836 * It's inline, so penalty for filesystems that don't use sticky bit is
1837 * minimal. 1837 * minimal.
1838 */ 1838 */
1839 static inline int check_sticky(struct inode *dir, struct inode *inode) 1839 static inline int check_sticky(struct inode *dir, struct inode *inode)
1840 { 1840 {
1841 uid_t fsuid = current_fsuid(); 1841 uid_t fsuid = current_fsuid();
1842 1842
1843 if (!(dir->i_mode & S_ISVTX)) 1843 if (!(dir->i_mode & S_ISVTX))
1844 return 0; 1844 return 0;
1845 if (current_user_ns() != inode_userns(inode)) 1845 if (current_user_ns() != inode_userns(inode))
1846 goto other_userns; 1846 goto other_userns;
1847 if (inode->i_uid == fsuid) 1847 if (inode->i_uid == fsuid)
1848 return 0; 1848 return 0;
1849 if (dir->i_uid == fsuid) 1849 if (dir->i_uid == fsuid)
1850 return 0; 1850 return 0;
1851 1851
1852 other_userns: 1852 other_userns:
1853 return !ns_capable(inode_userns(inode), CAP_FOWNER); 1853 return !ns_capable(inode_userns(inode), CAP_FOWNER);
1854 } 1854 }
1855 1855
1856 /* 1856 /*
1857 * Check whether we can remove a link victim from directory dir, check 1857 * Check whether we can remove a link victim from directory dir, check
1858 * whether the type of victim is right. 1858 * whether the type of victim is right.
1859 * 1. We can't do it if dir is read-only (done in permission()) 1859 * 1. We can't do it if dir is read-only (done in permission())
1860 * 2. We should have write and exec permissions on dir 1860 * 2. We should have write and exec permissions on dir
1861 * 3. We can't remove anything from append-only dir 1861 * 3. We can't remove anything from append-only dir
1862 * 4. We can't do anything with immutable dir (done in permission()) 1862 * 4. We can't do anything with immutable dir (done in permission())
1863 * 5. If the sticky bit on dir is set we should either 1863 * 5. If the sticky bit on dir is set we should either
1864 * a. be owner of dir, or 1864 * a. be owner of dir, or
1865 * b. be owner of victim, or 1865 * b. be owner of victim, or
1866 * c. have CAP_FOWNER capability 1866 * c. have CAP_FOWNER capability
1867 * 6. If the victim is append-only or immutable we can't do antyhing with 1867 * 6. If the victim is append-only or immutable we can't do antyhing with
1868 * links pointing to it. 1868 * links pointing to it.
1869 * 7. If we were asked to remove a directory and victim isn't one - ENOTDIR. 1869 * 7. If we were asked to remove a directory and victim isn't one - ENOTDIR.
1870 * 8. If we were asked to remove a non-directory and victim isn't one - EISDIR. 1870 * 8. If we were asked to remove a non-directory and victim isn't one - EISDIR.
1871 * 9. We can't remove a root or mountpoint. 1871 * 9. We can't remove a root or mountpoint.
1872 * 10. We don't allow removal of NFS sillyrenamed files; it's handled by 1872 * 10. We don't allow removal of NFS sillyrenamed files; it's handled by
1873 * nfs_async_unlink(). 1873 * nfs_async_unlink().
1874 */ 1874 */
1875 static int may_delete(struct inode *dir,struct dentry *victim,int isdir) 1875 static int may_delete(struct inode *dir,struct dentry *victim,int isdir)
1876 { 1876 {
1877 int error; 1877 int error;
1878 1878
1879 if (!victim->d_inode) 1879 if (!victim->d_inode)
1880 return -ENOENT; 1880 return -ENOENT;
1881 1881
1882 BUG_ON(victim->d_parent->d_inode != dir); 1882 BUG_ON(victim->d_parent->d_inode != dir);
1883 audit_inode_child(victim, dir); 1883 audit_inode_child(victim, dir);
1884 1884
1885 error = inode_permission(dir, MAY_WRITE | MAY_EXEC); 1885 error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
1886 if (error) 1886 if (error)
1887 return error; 1887 return error;
1888 if (IS_APPEND(dir)) 1888 if (IS_APPEND(dir))
1889 return -EPERM; 1889 return -EPERM;
1890 if (check_sticky(dir, victim->d_inode)||IS_APPEND(victim->d_inode)|| 1890 if (check_sticky(dir, victim->d_inode)||IS_APPEND(victim->d_inode)||
1891 IS_IMMUTABLE(victim->d_inode) || IS_SWAPFILE(victim->d_inode)) 1891 IS_IMMUTABLE(victim->d_inode) || IS_SWAPFILE(victim->d_inode))
1892 return -EPERM; 1892 return -EPERM;
1893 if (isdir) { 1893 if (isdir) {
1894 if (!S_ISDIR(victim->d_inode->i_mode)) 1894 if (!S_ISDIR(victim->d_inode->i_mode))
1895 return -ENOTDIR; 1895 return -ENOTDIR;
1896 if (IS_ROOT(victim)) 1896 if (IS_ROOT(victim))
1897 return -EBUSY; 1897 return -EBUSY;
1898 } else if (S_ISDIR(victim->d_inode->i_mode)) 1898 } else if (S_ISDIR(victim->d_inode->i_mode))
1899 return -EISDIR; 1899 return -EISDIR;
1900 if (IS_DEADDIR(dir)) 1900 if (IS_DEADDIR(dir))
1901 return -ENOENT; 1901 return -ENOENT;
1902 if (victim->d_flags & DCACHE_NFSFS_RENAMED) 1902 if (victim->d_flags & DCACHE_NFSFS_RENAMED)
1903 return -EBUSY; 1903 return -EBUSY;
1904 return 0; 1904 return 0;
1905 } 1905 }
1906 1906
1907 /* Check whether we can create an object with dentry child in directory 1907 /* Check whether we can create an object with dentry child in directory
1908 * dir. 1908 * dir.
1909 * 1. We can't do it if child already exists (open has special treatment for 1909 * 1. We can't do it if child already exists (open has special treatment for
1910 * this case, but since we are inlined it's OK) 1910 * this case, but since we are inlined it's OK)
1911 * 2. We can't do it if dir is read-only (done in permission()) 1911 * 2. We can't do it if dir is read-only (done in permission())
1912 * 3. We should have write and exec permissions on dir 1912 * 3. We should have write and exec permissions on dir
1913 * 4. We can't do it if dir is immutable (done in permission()) 1913 * 4. We can't do it if dir is immutable (done in permission())
1914 */ 1914 */
1915 static inline int may_create(struct inode *dir, struct dentry *child) 1915 static inline int may_create(struct inode *dir, struct dentry *child)
1916 { 1916 {
1917 if (child->d_inode) 1917 if (child->d_inode)
1918 return -EEXIST; 1918 return -EEXIST;
1919 if (IS_DEADDIR(dir)) 1919 if (IS_DEADDIR(dir))
1920 return -ENOENT; 1920 return -ENOENT;
1921 return inode_permission(dir, MAY_WRITE | MAY_EXEC); 1921 return inode_permission(dir, MAY_WRITE | MAY_EXEC);
1922 } 1922 }
1923 1923
1924 /* 1924 /*
1925 * p1 and p2 should be directories on the same fs. 1925 * p1 and p2 should be directories on the same fs.
1926 */ 1926 */
1927 struct dentry *lock_rename(struct dentry *p1, struct dentry *p2) 1927 struct dentry *lock_rename(struct dentry *p1, struct dentry *p2)
1928 { 1928 {
1929 struct dentry *p; 1929 struct dentry *p;
1930 1930
1931 if (p1 == p2) { 1931 if (p1 == p2) {
1932 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT); 1932 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
1933 return NULL; 1933 return NULL;
1934 } 1934 }
1935 1935
1936 mutex_lock(&p1->d_inode->i_sb->s_vfs_rename_mutex); 1936 mutex_lock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
1937 1937
1938 p = d_ancestor(p2, p1); 1938 p = d_ancestor(p2, p1);
1939 if (p) { 1939 if (p) {
1940 mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_PARENT); 1940 mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_PARENT);
1941 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_CHILD); 1941 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_CHILD);
1942 return p; 1942 return p;
1943 } 1943 }
1944 1944
1945 p = d_ancestor(p1, p2); 1945 p = d_ancestor(p1, p2);
1946 if (p) { 1946 if (p) {
1947 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT); 1947 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
1948 mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD); 1948 mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
1949 return p; 1949 return p;
1950 } 1950 }
1951 1951
1952 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT); 1952 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
1953 mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD); 1953 mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
1954 return NULL; 1954 return NULL;
1955 } 1955 }
1956 1956
1957 void unlock_rename(struct dentry *p1, struct dentry *p2) 1957 void unlock_rename(struct dentry *p1, struct dentry *p2)
1958 { 1958 {
1959 mutex_unlock(&p1->d_inode->i_mutex); 1959 mutex_unlock(&p1->d_inode->i_mutex);
1960 if (p1 != p2) { 1960 if (p1 != p2) {
1961 mutex_unlock(&p2->d_inode->i_mutex); 1961 mutex_unlock(&p2->d_inode->i_mutex);
1962 mutex_unlock(&p1->d_inode->i_sb->s_vfs_rename_mutex); 1962 mutex_unlock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
1963 } 1963 }
1964 } 1964 }
1965 1965
1966 int vfs_create(struct inode *dir, struct dentry *dentry, int mode, 1966 int vfs_create(struct inode *dir, struct dentry *dentry, int mode,
1967 struct nameidata *nd) 1967 struct nameidata *nd)
1968 { 1968 {
1969 int error = may_create(dir, dentry); 1969 int error = may_create(dir, dentry);
1970 1970
1971 if (error) 1971 if (error)
1972 return error; 1972 return error;
1973 1973
1974 if (!dir->i_op->create) 1974 if (!dir->i_op->create)
1975 return -EACCES; /* shouldn't it be ENOSYS? */ 1975 return -EACCES; /* shouldn't it be ENOSYS? */
1976 mode &= S_IALLUGO; 1976 mode &= S_IALLUGO;
1977 mode |= S_IFREG; 1977 mode |= S_IFREG;
1978 error = security_inode_create(dir, dentry, mode); 1978 error = security_inode_create(dir, dentry, mode);
1979 if (error) 1979 if (error)
1980 return error; 1980 return error;
1981 error = dir->i_op->create(dir, dentry, mode, nd); 1981 error = dir->i_op->create(dir, dentry, mode, nd);
1982 if (!error) 1982 if (!error)
1983 fsnotify_create(dir, dentry); 1983 fsnotify_create(dir, dentry);
1984 return error; 1984 return error;
1985 } 1985 }
1986 1986
1987 static int may_open(struct path *path, int acc_mode, int flag) 1987 static int may_open(struct path *path, int acc_mode, int flag)
1988 { 1988 {
1989 struct dentry *dentry = path->dentry; 1989 struct dentry *dentry = path->dentry;
1990 struct inode *inode = dentry->d_inode; 1990 struct inode *inode = dentry->d_inode;
1991 int error; 1991 int error;
1992 1992
1993 /* O_PATH? */ 1993 /* O_PATH? */
1994 if (!acc_mode) 1994 if (!acc_mode)
1995 return 0; 1995 return 0;
1996 1996
1997 if (!inode) 1997 if (!inode)
1998 return -ENOENT; 1998 return -ENOENT;
1999 1999
2000 switch (inode->i_mode & S_IFMT) { 2000 switch (inode->i_mode & S_IFMT) {
2001 case S_IFLNK: 2001 case S_IFLNK:
2002 return -ELOOP; 2002 return -ELOOP;
2003 case S_IFDIR: 2003 case S_IFDIR:
2004 if (acc_mode & MAY_WRITE) 2004 if (acc_mode & MAY_WRITE)
2005 return -EISDIR; 2005 return -EISDIR;
2006 break; 2006 break;
2007 case S_IFBLK: 2007 case S_IFBLK:
2008 case S_IFCHR: 2008 case S_IFCHR:
2009 if (path->mnt->mnt_flags & MNT_NODEV) 2009 if (path->mnt->mnt_flags & MNT_NODEV)
2010 return -EACCES; 2010 return -EACCES;
2011 /*FALLTHRU*/ 2011 /*FALLTHRU*/
2012 case S_IFIFO: 2012 case S_IFIFO:
2013 case S_IFSOCK: 2013 case S_IFSOCK:
2014 flag &= ~O_TRUNC; 2014 flag &= ~O_TRUNC;
2015 break; 2015 break;
2016 } 2016 }
2017 2017
2018 error = inode_permission(inode, acc_mode); 2018 error = inode_permission(inode, acc_mode);
2019 if (error) 2019 if (error)
2020 return error; 2020 return error;
2021 2021
2022 /* 2022 /*
2023 * An append-only file must be opened in append mode for writing. 2023 * An append-only file must be opened in append mode for writing.
2024 */ 2024 */
2025 if (IS_APPEND(inode)) { 2025 if (IS_APPEND(inode)) {
2026 if ((flag & O_ACCMODE) != O_RDONLY && !(flag & O_APPEND)) 2026 if ((flag & O_ACCMODE) != O_RDONLY && !(flag & O_APPEND))
2027 return -EPERM; 2027 return -EPERM;
2028 if (flag & O_TRUNC) 2028 if (flag & O_TRUNC)
2029 return -EPERM; 2029 return -EPERM;
2030 } 2030 }
2031 2031
2032 /* O_NOATIME can only be set by the owner or superuser */ 2032 /* O_NOATIME can only be set by the owner or superuser */
2033 if (flag & O_NOATIME && !inode_owner_or_capable(inode)) 2033 if (flag & O_NOATIME && !inode_owner_or_capable(inode))
2034 return -EPERM; 2034 return -EPERM;
2035 2035
2036 /* 2036 /*
2037 * Ensure there are no outstanding leases on the file. 2037 * Ensure there are no outstanding leases on the file.
2038 */ 2038 */
2039 return break_lease(inode, flag); 2039 return break_lease(inode, flag);
2040 } 2040 }
2041 2041
2042 static int handle_truncate(struct file *filp) 2042 static int handle_truncate(struct file *filp)
2043 { 2043 {
2044 struct path *path = &filp->f_path; 2044 struct path *path = &filp->f_path;
2045 struct inode *inode = path->dentry->d_inode; 2045 struct inode *inode = path->dentry->d_inode;
2046 int error = get_write_access(inode); 2046 int error = get_write_access(inode);
2047 if (error) 2047 if (error)
2048 return error; 2048 return error;
2049 /* 2049 /*
2050 * Refuse to truncate files with mandatory locks held on them. 2050 * Refuse to truncate files with mandatory locks held on them.
2051 */ 2051 */
2052 error = locks_verify_locked(inode); 2052 error = locks_verify_locked(inode);
2053 if (!error) 2053 if (!error)
2054 error = security_path_truncate(path); 2054 error = security_path_truncate(path);
2055 if (!error) { 2055 if (!error) {
2056 error = do_truncate(path->dentry, 0, 2056 error = do_truncate(path->dentry, 0,
2057 ATTR_MTIME|ATTR_CTIME|ATTR_OPEN, 2057 ATTR_MTIME|ATTR_CTIME|ATTR_OPEN,
2058 filp); 2058 filp);
2059 } 2059 }
2060 put_write_access(inode); 2060 put_write_access(inode);
2061 return error; 2061 return error;
2062 } 2062 }
2063 2063
2064 /* 2064 /*
2065 * Note that while the flag value (low two bits) for sys_open means: 2065 * Note that while the flag value (low two bits) for sys_open means:
2066 * 00 - read-only 2066 * 00 - read-only
2067 * 01 - write-only 2067 * 01 - write-only
2068 * 10 - read-write 2068 * 10 - read-write
2069 * 11 - special 2069 * 11 - special
2070 * it is changed into 2070 * it is changed into
2071 * 00 - no permissions needed 2071 * 00 - no permissions needed
2072 * 01 - read-permission 2072 * 01 - read-permission
2073 * 10 - write-permission 2073 * 10 - write-permission
2074 * 11 - read-write 2074 * 11 - read-write
2075 * for the internal routines (ie open_namei()/follow_link() etc) 2075 * for the internal routines (ie open_namei()/follow_link() etc)
2076 * This is more logical, and also allows the 00 "no perm needed" 2076 * This is more logical, and also allows the 00 "no perm needed"
2077 * to be used for symlinks (where the permissions are checked 2077 * to be used for symlinks (where the permissions are checked
2078 * later). 2078 * later).
2079 * 2079 *
2080 */ 2080 */
2081 static inline int open_to_namei_flags(int flag) 2081 static inline int open_to_namei_flags(int flag)
2082 { 2082 {
2083 if ((flag+1) & O_ACCMODE) 2083 if ((flag+1) & O_ACCMODE)
2084 flag++; 2084 flag++;
2085 return flag; 2085 return flag;
2086 } 2086 }
2087 2087
2088 /* 2088 /*
2089 * Handle the last step of open() 2089 * Handle the last step of open()
2090 */ 2090 */
2091 static struct file *do_last(struct nameidata *nd, struct path *path, 2091 static struct file *do_last(struct nameidata *nd, struct path *path,
2092 const struct open_flags *op, const char *pathname) 2092 const struct open_flags *op, const char *pathname)
2093 { 2093 {
2094 struct dentry *dir = nd->path.dentry; 2094 struct dentry *dir = nd->path.dentry;
2095 struct dentry *dentry; 2095 struct dentry *dentry;
2096 int open_flag = op->open_flag; 2096 int open_flag = op->open_flag;
2097 int will_truncate = open_flag & O_TRUNC; 2097 int will_truncate = open_flag & O_TRUNC;
2098 int want_write = 0; 2098 int want_write = 0;
2099 int acc_mode = op->acc_mode; 2099 int acc_mode = op->acc_mode;
2100 struct file *filp; 2100 struct file *filp;
2101 int error; 2101 int error;
2102 2102
2103 nd->flags &= ~LOOKUP_PARENT; 2103 nd->flags &= ~LOOKUP_PARENT;
2104 nd->flags |= op->intent; 2104 nd->flags |= op->intent;
2105 2105
2106 switch (nd->last_type) { 2106 switch (nd->last_type) {
2107 case LAST_DOTDOT: 2107 case LAST_DOTDOT:
2108 case LAST_DOT: 2108 case LAST_DOT:
2109 error = handle_dots(nd, nd->last_type); 2109 error = handle_dots(nd, nd->last_type);
2110 if (error) 2110 if (error)
2111 return ERR_PTR(error); 2111 return ERR_PTR(error);
2112 /* fallthrough */ 2112 /* fallthrough */
2113 case LAST_ROOT: 2113 case LAST_ROOT:
2114 error = complete_walk(nd); 2114 error = complete_walk(nd);
2115 if (error) 2115 if (error)
2116 return ERR_PTR(error); 2116 return ERR_PTR(error);
2117 audit_inode(pathname, nd->path.dentry); 2117 audit_inode(pathname, nd->path.dentry);
2118 if (open_flag & O_CREAT) { 2118 if (open_flag & O_CREAT) {
2119 error = -EISDIR; 2119 error = -EISDIR;
2120 goto exit; 2120 goto exit;
2121 } 2121 }
2122 goto ok; 2122 goto ok;
2123 case LAST_BIND: 2123 case LAST_BIND:
2124 error = complete_walk(nd); 2124 error = complete_walk(nd);
2125 if (error) 2125 if (error)
2126 return ERR_PTR(error); 2126 return ERR_PTR(error);
2127 audit_inode(pathname, dir); 2127 audit_inode(pathname, dir);
2128 goto ok; 2128 goto ok;
2129 } 2129 }
2130 2130
2131 if (!(open_flag & O_CREAT)) { 2131 if (!(open_flag & O_CREAT)) {
2132 int symlink_ok = 0; 2132 int symlink_ok = 0;
2133 if (nd->last.name[nd->last.len]) 2133 if (nd->last.name[nd->last.len])
2134 nd->flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY; 2134 nd->flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
2135 if (open_flag & O_PATH && !(nd->flags & LOOKUP_FOLLOW)) 2135 if (open_flag & O_PATH && !(nd->flags & LOOKUP_FOLLOW))
2136 symlink_ok = 1; 2136 symlink_ok = 1;
2137 /* we _can_ be in RCU mode here */ 2137 /* we _can_ be in RCU mode here */
2138 error = walk_component(nd, path, &nd->last, LAST_NORM, 2138 error = walk_component(nd, path, &nd->last, LAST_NORM,
2139 !symlink_ok); 2139 !symlink_ok);
2140 if (error < 0) 2140 if (error < 0)
2141 return ERR_PTR(error); 2141 return ERR_PTR(error);
2142 if (error) /* symlink */ 2142 if (error) /* symlink */
2143 return NULL; 2143 return NULL;
2144 /* sayonara */ 2144 /* sayonara */
2145 error = complete_walk(nd); 2145 error = complete_walk(nd);
2146 if (error) 2146 if (error)
2147 return ERR_PTR(-ECHILD); 2147 return ERR_PTR(-ECHILD);
2148 2148
2149 error = -ENOTDIR; 2149 error = -ENOTDIR;
2150 if (nd->flags & LOOKUP_DIRECTORY) { 2150 if (nd->flags & LOOKUP_DIRECTORY) {
2151 if (!nd->inode->i_op->lookup) 2151 if (!nd->inode->i_op->lookup)
2152 goto exit; 2152 goto exit;
2153 } 2153 }
2154 audit_inode(pathname, nd->path.dentry); 2154 audit_inode(pathname, nd->path.dentry);
2155 goto ok; 2155 goto ok;
2156 } 2156 }
2157 2157
2158 /* create side of things */ 2158 /* create side of things */
2159 error = complete_walk(nd); 2159 error = complete_walk(nd);
2160 if (error) 2160 if (error)
2161 return ERR_PTR(error); 2161 return ERR_PTR(error);
2162 2162
2163 audit_inode(pathname, dir); 2163 audit_inode(pathname, dir);
2164 error = -EISDIR; 2164 error = -EISDIR;
2165 /* trailing slashes? */ 2165 /* trailing slashes? */
2166 if (nd->last.name[nd->last.len]) 2166 if (nd->last.name[nd->last.len])
2167 goto exit; 2167 goto exit;
2168 2168
2169 mutex_lock(&dir->d_inode->i_mutex); 2169 mutex_lock(&dir->d_inode->i_mutex);
2170 2170
2171 dentry = lookup_hash(nd); 2171 dentry = lookup_hash(nd);
2172 error = PTR_ERR(dentry); 2172 error = PTR_ERR(dentry);
2173 if (IS_ERR(dentry)) { 2173 if (IS_ERR(dentry)) {
2174 mutex_unlock(&dir->d_inode->i_mutex); 2174 mutex_unlock(&dir->d_inode->i_mutex);
2175 goto exit; 2175 goto exit;
2176 } 2176 }
2177 2177
2178 path->dentry = dentry; 2178 path->dentry = dentry;
2179 path->mnt = nd->path.mnt; 2179 path->mnt = nd->path.mnt;
2180 2180
2181 /* Negative dentry, just create the file */ 2181 /* Negative dentry, just create the file */
2182 if (!dentry->d_inode) { 2182 if (!dentry->d_inode) {
2183 int mode = op->mode; 2183 int mode = op->mode;
2184 if (!IS_POSIXACL(dir->d_inode)) 2184 if (!IS_POSIXACL(dir->d_inode))
2185 mode &= ~current_umask(); 2185 mode &= ~current_umask();
2186 /* 2186 /*
2187 * This write is needed to ensure that a 2187 * This write is needed to ensure that a
2188 * rw->ro transition does not occur between 2188 * rw->ro transition does not occur between
2189 * the time when the file is created and when 2189 * the time when the file is created and when
2190 * a permanent write count is taken through 2190 * a permanent write count is taken through
2191 * the 'struct file' in nameidata_to_filp(). 2191 * the 'struct file' in nameidata_to_filp().
2192 */ 2192 */
2193 error = mnt_want_write(nd->path.mnt); 2193 error = mnt_want_write(nd->path.mnt);
2194 if (error) 2194 if (error)
2195 goto exit_mutex_unlock; 2195 goto exit_mutex_unlock;
2196 want_write = 1; 2196 want_write = 1;
2197 /* Don't check for write permission, don't truncate */ 2197 /* Don't check for write permission, don't truncate */
2198 open_flag &= ~O_TRUNC; 2198 open_flag &= ~O_TRUNC;
2199 will_truncate = 0; 2199 will_truncate = 0;
2200 acc_mode = MAY_OPEN; 2200 acc_mode = MAY_OPEN;
2201 error = security_path_mknod(&nd->path, dentry, mode, 0); 2201 error = security_path_mknod(&nd->path, dentry, mode, 0);
2202 if (error) 2202 if (error)
2203 goto exit_mutex_unlock; 2203 goto exit_mutex_unlock;
2204 error = vfs_create(dir->d_inode, dentry, mode, nd); 2204 error = vfs_create(dir->d_inode, dentry, mode, nd);
2205 if (error) 2205 if (error)
2206 goto exit_mutex_unlock; 2206 goto exit_mutex_unlock;
2207 mutex_unlock(&dir->d_inode->i_mutex); 2207 mutex_unlock(&dir->d_inode->i_mutex);
2208 dput(nd->path.dentry); 2208 dput(nd->path.dentry);
2209 nd->path.dentry = dentry; 2209 nd->path.dentry = dentry;
2210 goto common; 2210 goto common;
2211 } 2211 }
2212 2212
2213 /* 2213 /*
2214 * It already exists. 2214 * It already exists.
2215 */ 2215 */
2216 mutex_unlock(&dir->d_inode->i_mutex); 2216 mutex_unlock(&dir->d_inode->i_mutex);
2217 audit_inode(pathname, path->dentry); 2217 audit_inode(pathname, path->dentry);
2218 2218
2219 error = -EEXIST; 2219 error = -EEXIST;
2220 if (open_flag & O_EXCL) 2220 if (open_flag & O_EXCL)
2221 goto exit_dput; 2221 goto exit_dput;
2222 2222
2223 error = follow_managed(path, nd->flags); 2223 error = follow_managed(path, nd->flags);
2224 if (error < 0) 2224 if (error < 0)
2225 goto exit_dput; 2225 goto exit_dput;
2226 2226
2227 error = -ENOENT; 2227 error = -ENOENT;
2228 if (!path->dentry->d_inode) 2228 if (!path->dentry->d_inode)
2229 goto exit_dput; 2229 goto exit_dput;
2230 2230
2231 if (path->dentry->d_inode->i_op->follow_link) 2231 if (path->dentry->d_inode->i_op->follow_link)
2232 return NULL; 2232 return NULL;
2233 2233
2234 path_to_nameidata(path, nd); 2234 path_to_nameidata(path, nd);
2235 nd->inode = path->dentry->d_inode; 2235 nd->inode = path->dentry->d_inode;
2236 error = -EISDIR; 2236 error = -EISDIR;
2237 if (S_ISDIR(nd->inode->i_mode)) 2237 if (S_ISDIR(nd->inode->i_mode))
2238 goto exit; 2238 goto exit;
2239 ok: 2239 ok:
2240 if (!S_ISREG(nd->inode->i_mode)) 2240 if (!S_ISREG(nd->inode->i_mode))
2241 will_truncate = 0; 2241 will_truncate = 0;
2242 2242
2243 if (will_truncate) { 2243 if (will_truncate) {
2244 error = mnt_want_write(nd->path.mnt); 2244 error = mnt_want_write(nd->path.mnt);
2245 if (error) 2245 if (error)
2246 goto exit; 2246 goto exit;
2247 want_write = 1; 2247 want_write = 1;
2248 } 2248 }
2249 common: 2249 common:
2250 error = may_open(&nd->path, acc_mode, open_flag); 2250 error = may_open(&nd->path, acc_mode, open_flag);
2251 if (error) 2251 if (error)
2252 goto exit; 2252 goto exit;
2253 filp = nameidata_to_filp(nd); 2253 filp = nameidata_to_filp(nd);
2254 if (!IS_ERR(filp)) { 2254 if (!IS_ERR(filp)) {
2255 error = ima_file_check(filp, op->acc_mode); 2255 error = ima_file_check(filp, op->acc_mode);
2256 if (error) { 2256 if (error) {
2257 fput(filp); 2257 fput(filp);
2258 filp = ERR_PTR(error); 2258 filp = ERR_PTR(error);
2259 } 2259 }
2260 } 2260 }
2261 if (!IS_ERR(filp)) { 2261 if (!IS_ERR(filp)) {
2262 if (will_truncate) { 2262 if (will_truncate) {
2263 error = handle_truncate(filp); 2263 error = handle_truncate(filp);
2264 if (error) { 2264 if (error) {
2265 fput(filp); 2265 fput(filp);
2266 filp = ERR_PTR(error); 2266 filp = ERR_PTR(error);
2267 } 2267 }
2268 } 2268 }
2269 } 2269 }
2270 out: 2270 out:
2271 if (want_write) 2271 if (want_write)
2272 mnt_drop_write(nd->path.mnt); 2272 mnt_drop_write(nd->path.mnt);
2273 path_put(&nd->path); 2273 path_put(&nd->path);
2274 return filp; 2274 return filp;
2275 2275
2276 exit_mutex_unlock: 2276 exit_mutex_unlock:
2277 mutex_unlock(&dir->d_inode->i_mutex); 2277 mutex_unlock(&dir->d_inode->i_mutex);
2278 exit_dput: 2278 exit_dput:
2279 path_put_conditional(path, nd); 2279 path_put_conditional(path, nd);
2280 exit: 2280 exit:
2281 filp = ERR_PTR(error); 2281 filp = ERR_PTR(error);
2282 goto out; 2282 goto out;
2283 } 2283 }
2284 2284
2285 static struct file *path_openat(int dfd, const char *pathname, 2285 static struct file *path_openat(int dfd, const char *pathname,
2286 struct nameidata *nd, const struct open_flags *op, int flags) 2286 struct nameidata *nd, const struct open_flags *op, int flags)
2287 { 2287 {
2288 struct file *base = NULL; 2288 struct file *base = NULL;
2289 struct file *filp; 2289 struct file *filp;
2290 struct path path; 2290 struct path path;
2291 int error; 2291 int error;
2292 2292
2293 filp = get_empty_filp(); 2293 filp = get_empty_filp();
2294 if (!filp) 2294 if (!filp)
2295 return ERR_PTR(-ENFILE); 2295 return ERR_PTR(-ENFILE);
2296 2296
2297 filp->f_flags = op->open_flag; 2297 filp->f_flags = op->open_flag;
2298 nd->intent.open.file = filp; 2298 nd->intent.open.file = filp;
2299 nd->intent.open.flags = open_to_namei_flags(op->open_flag); 2299 nd->intent.open.flags = open_to_namei_flags(op->open_flag);
2300 nd->intent.open.create_mode = op->mode; 2300 nd->intent.open.create_mode = op->mode;
2301 2301
2302 error = path_init(dfd, pathname, flags | LOOKUP_PARENT, nd, &base); 2302 error = path_init(dfd, pathname, flags | LOOKUP_PARENT, nd, &base);
2303 if (unlikely(error)) 2303 if (unlikely(error))
2304 goto out_filp; 2304 goto out_filp;
2305 2305
2306 current->total_link_count = 0; 2306 current->total_link_count = 0;
2307 error = link_path_walk(pathname, nd); 2307 error = link_path_walk(pathname, nd);
2308 if (unlikely(error)) 2308 if (unlikely(error))
2309 goto out_filp; 2309 goto out_filp;
2310 2310
2311 filp = do_last(nd, &path, op, pathname); 2311 filp = do_last(nd, &path, op, pathname);
2312 while (unlikely(!filp)) { /* trailing symlink */ 2312 while (unlikely(!filp)) { /* trailing symlink */
2313 struct path link = path; 2313 struct path link = path;
2314 void *cookie; 2314 void *cookie;
2315 if (!(nd->flags & LOOKUP_FOLLOW)) { 2315 if (!(nd->flags & LOOKUP_FOLLOW)) {
2316 path_put_conditional(&path, nd); 2316 path_put_conditional(&path, nd);
2317 path_put(&nd->path); 2317 path_put(&nd->path);
2318 filp = ERR_PTR(-ELOOP); 2318 filp = ERR_PTR(-ELOOP);
2319 break; 2319 break;
2320 } 2320 }
2321 nd->flags |= LOOKUP_PARENT; 2321 nd->flags |= LOOKUP_PARENT;
2322 nd->flags &= ~(LOOKUP_OPEN|LOOKUP_CREATE|LOOKUP_EXCL); 2322 nd->flags &= ~(LOOKUP_OPEN|LOOKUP_CREATE|LOOKUP_EXCL);
2323 error = follow_link(&link, nd, &cookie); 2323 error = follow_link(&link, nd, &cookie);
2324 if (unlikely(error)) 2324 if (unlikely(error))
2325 filp = ERR_PTR(error); 2325 filp = ERR_PTR(error);
2326 else 2326 else
2327 filp = do_last(nd, &path, op, pathname); 2327 filp = do_last(nd, &path, op, pathname);
2328 put_link(nd, &link, cookie); 2328 put_link(nd, &link, cookie);
2329 } 2329 }
2330 out: 2330 out:
2331 if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT)) 2331 if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT))
2332 path_put(&nd->root); 2332 path_put(&nd->root);
2333 if (base) 2333 if (base)
2334 fput(base); 2334 fput(base);
2335 release_open_intent(nd); 2335 release_open_intent(nd);
2336 return filp; 2336 return filp;
2337 2337
2338 out_filp: 2338 out_filp:
2339 filp = ERR_PTR(error); 2339 filp = ERR_PTR(error);
2340 goto out; 2340 goto out;
2341 } 2341 }
2342 2342
2343 struct file *do_filp_open(int dfd, const char *pathname, 2343 struct file *do_filp_open(int dfd, const char *pathname,
2344 const struct open_flags *op, int flags) 2344 const struct open_flags *op, int flags)
2345 { 2345 {
2346 struct nameidata nd; 2346 struct nameidata nd;
2347 struct file *filp; 2347 struct file *filp;
2348 2348
2349 filp = path_openat(dfd, pathname, &nd, op, flags | LOOKUP_RCU); 2349 filp = path_openat(dfd, pathname, &nd, op, flags | LOOKUP_RCU);
2350 if (unlikely(filp == ERR_PTR(-ECHILD))) 2350 if (unlikely(filp == ERR_PTR(-ECHILD)))
2351 filp = path_openat(dfd, pathname, &nd, op, flags); 2351 filp = path_openat(dfd, pathname, &nd, op, flags);
2352 if (unlikely(filp == ERR_PTR(-ESTALE))) 2352 if (unlikely(filp == ERR_PTR(-ESTALE)))
2353 filp = path_openat(dfd, pathname, &nd, op, flags | LOOKUP_REVAL); 2353 filp = path_openat(dfd, pathname, &nd, op, flags | LOOKUP_REVAL);
2354 return filp; 2354 return filp;
2355 } 2355 }
2356 2356
2357 struct file *do_file_open_root(struct dentry *dentry, struct vfsmount *mnt, 2357 struct file *do_file_open_root(struct dentry *dentry, struct vfsmount *mnt,
2358 const char *name, const struct open_flags *op, int flags) 2358 const char *name, const struct open_flags *op, int flags)
2359 { 2359 {
2360 struct nameidata nd; 2360 struct nameidata nd;
2361 struct file *file; 2361 struct file *file;
2362 2362
2363 nd.root.mnt = mnt; 2363 nd.root.mnt = mnt;
2364 nd.root.dentry = dentry; 2364 nd.root.dentry = dentry;
2365 2365
2366 flags |= LOOKUP_ROOT; 2366 flags |= LOOKUP_ROOT;
2367 2367
2368 if (dentry->d_inode->i_op->follow_link && op->intent & LOOKUP_OPEN) 2368 if (dentry->d_inode->i_op->follow_link && op->intent & LOOKUP_OPEN)
2369 return ERR_PTR(-ELOOP); 2369 return ERR_PTR(-ELOOP);
2370 2370
2371 file = path_openat(-1, name, &nd, op, flags | LOOKUP_RCU); 2371 file = path_openat(-1, name, &nd, op, flags | LOOKUP_RCU);
2372 if (unlikely(file == ERR_PTR(-ECHILD))) 2372 if (unlikely(file == ERR_PTR(-ECHILD)))
2373 file = path_openat(-1, name, &nd, op, flags); 2373 file = path_openat(-1, name, &nd, op, flags);
2374 if (unlikely(file == ERR_PTR(-ESTALE))) 2374 if (unlikely(file == ERR_PTR(-ESTALE)))
2375 file = path_openat(-1, name, &nd, op, flags | LOOKUP_REVAL); 2375 file = path_openat(-1, name, &nd, op, flags | LOOKUP_REVAL);
2376 return file; 2376 return file;
2377 } 2377 }
2378 2378
2379 /** 2379 /**
2380 * lookup_create - lookup a dentry, creating it if it doesn't exist 2380 * lookup_create - lookup a dentry, creating it if it doesn't exist
2381 * @nd: nameidata info 2381 * @nd: nameidata info
2382 * @is_dir: directory flag 2382 * @is_dir: directory flag
2383 * 2383 *
2384 * Simple function to lookup and return a dentry and create it 2384 * Simple function to lookup and return a dentry and create it
2385 * if it doesn't exist. Is SMP-safe. 2385 * if it doesn't exist. Is SMP-safe.
2386 * 2386 *
2387 * Returns with nd->path.dentry->d_inode->i_mutex locked. 2387 * Returns with nd->path.dentry->d_inode->i_mutex locked.
2388 */ 2388 */
2389 struct dentry *lookup_create(struct nameidata *nd, int is_dir) 2389 struct dentry *lookup_create(struct nameidata *nd, int is_dir)
2390 { 2390 {
2391 struct dentry *dentry = ERR_PTR(-EEXIST); 2391 struct dentry *dentry = ERR_PTR(-EEXIST);
2392 2392
2393 mutex_lock_nested(&nd->path.dentry->d_inode->i_mutex, I_MUTEX_PARENT); 2393 mutex_lock_nested(&nd->path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2394 /* 2394 /*
2395 * Yucky last component or no last component at all? 2395 * Yucky last component or no last component at all?
2396 * (foo/., foo/.., /////) 2396 * (foo/., foo/.., /////)
2397 */ 2397 */
2398 if (nd->last_type != LAST_NORM) 2398 if (nd->last_type != LAST_NORM)
2399 goto fail; 2399 goto fail;
2400 nd->flags &= ~LOOKUP_PARENT; 2400 nd->flags &= ~LOOKUP_PARENT;
2401 nd->flags |= LOOKUP_CREATE | LOOKUP_EXCL; 2401 nd->flags |= LOOKUP_CREATE | LOOKUP_EXCL;
2402 nd->intent.open.flags = O_EXCL; 2402 nd->intent.open.flags = O_EXCL;
2403 2403
2404 /* 2404 /*
2405 * Do the final lookup. 2405 * Do the final lookup.
2406 */ 2406 */
2407 dentry = lookup_hash(nd); 2407 dentry = lookup_hash(nd);
2408 if (IS_ERR(dentry)) 2408 if (IS_ERR(dentry))
2409 goto fail; 2409 goto fail;
2410 2410
2411 if (dentry->d_inode) 2411 if (dentry->d_inode)
2412 goto eexist; 2412 goto eexist;
2413 /* 2413 /*
2414 * Special case - lookup gave negative, but... we had foo/bar/ 2414 * Special case - lookup gave negative, but... we had foo/bar/
2415 * From the vfs_mknod() POV we just have a negative dentry - 2415 * From the vfs_mknod() POV we just have a negative dentry -
2416 * all is fine. Let's be bastards - you had / on the end, you've 2416 * all is fine. Let's be bastards - you had / on the end, you've
2417 * been asking for (non-existent) directory. -ENOENT for you. 2417 * been asking for (non-existent) directory. -ENOENT for you.
2418 */ 2418 */
2419 if (unlikely(!is_dir && nd->last.name[nd->last.len])) { 2419 if (unlikely(!is_dir && nd->last.name[nd->last.len])) {
2420 dput(dentry); 2420 dput(dentry);
2421 dentry = ERR_PTR(-ENOENT); 2421 dentry = ERR_PTR(-ENOENT);
2422 } 2422 }
2423 return dentry; 2423 return dentry;
2424 eexist: 2424 eexist:
2425 dput(dentry); 2425 dput(dentry);
2426 dentry = ERR_PTR(-EEXIST); 2426 dentry = ERR_PTR(-EEXIST);
2427 fail: 2427 fail:
2428 return dentry; 2428 return dentry;
2429 } 2429 }
2430 EXPORT_SYMBOL_GPL(lookup_create); 2430 EXPORT_SYMBOL_GPL(lookup_create);
2431 2431
2432 int vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev) 2432 int vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
2433 { 2433 {
2434 int error = may_create(dir, dentry); 2434 int error = may_create(dir, dentry);
2435 2435
2436 if (error) 2436 if (error)
2437 return error; 2437 return error;
2438 2438
2439 if ((S_ISCHR(mode) || S_ISBLK(mode)) && 2439 if ((S_ISCHR(mode) || S_ISBLK(mode)) &&
2440 !ns_capable(inode_userns(dir), CAP_MKNOD)) 2440 !ns_capable(inode_userns(dir), CAP_MKNOD))
2441 return -EPERM; 2441 return -EPERM;
2442 2442
2443 if (!dir->i_op->mknod) 2443 if (!dir->i_op->mknod)
2444 return -EPERM; 2444 return -EPERM;
2445 2445
2446 error = devcgroup_inode_mknod(mode, dev); 2446 error = devcgroup_inode_mknod(mode, dev);
2447 if (error) 2447 if (error)
2448 return error; 2448 return error;
2449 2449
2450 error = security_inode_mknod(dir, dentry, mode, dev); 2450 error = security_inode_mknod(dir, dentry, mode, dev);
2451 if (error) 2451 if (error)
2452 return error; 2452 return error;
2453 2453
2454 error = dir->i_op->mknod(dir, dentry, mode, dev); 2454 error = dir->i_op->mknod(dir, dentry, mode, dev);
2455 if (!error) 2455 if (!error)
2456 fsnotify_create(dir, dentry); 2456 fsnotify_create(dir, dentry);
2457 return error; 2457 return error;
2458 } 2458 }
2459 2459
2460 static int may_mknod(mode_t mode) 2460 static int may_mknod(mode_t mode)
2461 { 2461 {
2462 switch (mode & S_IFMT) { 2462 switch (mode & S_IFMT) {
2463 case S_IFREG: 2463 case S_IFREG:
2464 case S_IFCHR: 2464 case S_IFCHR:
2465 case S_IFBLK: 2465 case S_IFBLK:
2466 case S_IFIFO: 2466 case S_IFIFO:
2467 case S_IFSOCK: 2467 case S_IFSOCK:
2468 case 0: /* zero mode translates to S_IFREG */ 2468 case 0: /* zero mode translates to S_IFREG */
2469 return 0; 2469 return 0;
2470 case S_IFDIR: 2470 case S_IFDIR:
2471 return -EPERM; 2471 return -EPERM;
2472 default: 2472 default:
2473 return -EINVAL; 2473 return -EINVAL;
2474 } 2474 }
2475 } 2475 }
2476 2476
2477 SYSCALL_DEFINE4(mknodat, int, dfd, const char __user *, filename, int, mode, 2477 SYSCALL_DEFINE4(mknodat, int, dfd, const char __user *, filename, int, mode,
2478 unsigned, dev) 2478 unsigned, dev)
2479 { 2479 {
2480 int error; 2480 int error;
2481 char *tmp; 2481 char *tmp;
2482 struct dentry *dentry; 2482 struct dentry *dentry;
2483 struct nameidata nd; 2483 struct nameidata nd;
2484 2484
2485 if (S_ISDIR(mode)) 2485 if (S_ISDIR(mode))
2486 return -EPERM; 2486 return -EPERM;
2487 2487
2488 error = user_path_parent(dfd, filename, &nd, &tmp); 2488 error = user_path_parent(dfd, filename, &nd, &tmp);
2489 if (error) 2489 if (error)
2490 return error; 2490 return error;
2491 2491
2492 dentry = lookup_create(&nd, 0); 2492 dentry = lookup_create(&nd, 0);
2493 if (IS_ERR(dentry)) { 2493 if (IS_ERR(dentry)) {
2494 error = PTR_ERR(dentry); 2494 error = PTR_ERR(dentry);
2495 goto out_unlock; 2495 goto out_unlock;
2496 } 2496 }
2497 if (!IS_POSIXACL(nd.path.dentry->d_inode)) 2497 if (!IS_POSIXACL(nd.path.dentry->d_inode))
2498 mode &= ~current_umask(); 2498 mode &= ~current_umask();
2499 error = may_mknod(mode); 2499 error = may_mknod(mode);
2500 if (error) 2500 if (error)
2501 goto out_dput; 2501 goto out_dput;
2502 error = mnt_want_write(nd.path.mnt); 2502 error = mnt_want_write(nd.path.mnt);
2503 if (error) 2503 if (error)
2504 goto out_dput; 2504 goto out_dput;
2505 error = security_path_mknod(&nd.path, dentry, mode, dev); 2505 error = security_path_mknod(&nd.path, dentry, mode, dev);
2506 if (error) 2506 if (error)
2507 goto out_drop_write; 2507 goto out_drop_write;
2508 switch (mode & S_IFMT) { 2508 switch (mode & S_IFMT) {
2509 case 0: case S_IFREG: 2509 case 0: case S_IFREG:
2510 error = vfs_create(nd.path.dentry->d_inode,dentry,mode,&nd); 2510 error = vfs_create(nd.path.dentry->d_inode,dentry,mode,&nd);
2511 break; 2511 break;
2512 case S_IFCHR: case S_IFBLK: 2512 case S_IFCHR: case S_IFBLK:
2513 error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode, 2513 error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,
2514 new_decode_dev(dev)); 2514 new_decode_dev(dev));
2515 break; 2515 break;
2516 case S_IFIFO: case S_IFSOCK: 2516 case S_IFIFO: case S_IFSOCK:
2517 error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,0); 2517 error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,0);
2518 break; 2518 break;
2519 } 2519 }
2520 out_drop_write: 2520 out_drop_write:
2521 mnt_drop_write(nd.path.mnt); 2521 mnt_drop_write(nd.path.mnt);
2522 out_dput: 2522 out_dput:
2523 dput(dentry); 2523 dput(dentry);
2524 out_unlock: 2524 out_unlock:
2525 mutex_unlock(&nd.path.dentry->d_inode->i_mutex); 2525 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2526 path_put(&nd.path); 2526 path_put(&nd.path);
2527 putname(tmp); 2527 putname(tmp);
2528 2528
2529 return error; 2529 return error;
2530 } 2530 }
2531 2531
2532 SYSCALL_DEFINE3(mknod, const char __user *, filename, int, mode, unsigned, dev) 2532 SYSCALL_DEFINE3(mknod, const char __user *, filename, int, mode, unsigned, dev)
2533 { 2533 {
2534 return sys_mknodat(AT_FDCWD, filename, mode, dev); 2534 return sys_mknodat(AT_FDCWD, filename, mode, dev);
2535 } 2535 }
2536 2536
2537 int vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode) 2537 int vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
2538 { 2538 {
2539 int error = may_create(dir, dentry); 2539 int error = may_create(dir, dentry);
2540 2540
2541 if (error) 2541 if (error)
2542 return error; 2542 return error;
2543 2543
2544 if (!dir->i_op->mkdir) 2544 if (!dir->i_op->mkdir)
2545 return -EPERM; 2545 return -EPERM;
2546 2546
2547 mode &= (S_IRWXUGO|S_ISVTX); 2547 mode &= (S_IRWXUGO|S_ISVTX);
2548 error = security_inode_mkdir(dir, dentry, mode); 2548 error = security_inode_mkdir(dir, dentry, mode);
2549 if (error) 2549 if (error)
2550 return error; 2550 return error;
2551 2551
2552 error = dir->i_op->mkdir(dir, dentry, mode); 2552 error = dir->i_op->mkdir(dir, dentry, mode);
2553 if (!error) 2553 if (!error)
2554 fsnotify_mkdir(dir, dentry); 2554 fsnotify_mkdir(dir, dentry);
2555 return error; 2555 return error;
2556 } 2556 }
2557 2557
2558 SYSCALL_DEFINE3(mkdirat, int, dfd, const char __user *, pathname, int, mode) 2558 SYSCALL_DEFINE3(mkdirat, int, dfd, const char __user *, pathname, int, mode)
2559 { 2559 {
2560 int error = 0; 2560 int error = 0;
2561 char * tmp; 2561 char * tmp;
2562 struct dentry *dentry; 2562 struct dentry *dentry;
2563 struct nameidata nd; 2563 struct nameidata nd;
2564 2564
2565 error = user_path_parent(dfd, pathname, &nd, &tmp); 2565 error = user_path_parent(dfd, pathname, &nd, &tmp);
2566 if (error) 2566 if (error)
2567 goto out_err; 2567 goto out_err;
2568 2568
2569 dentry = lookup_create(&nd, 1); 2569 dentry = lookup_create(&nd, 1);
2570 error = PTR_ERR(dentry); 2570 error = PTR_ERR(dentry);
2571 if (IS_ERR(dentry)) 2571 if (IS_ERR(dentry))
2572 goto out_unlock; 2572 goto out_unlock;
2573 2573
2574 if (!IS_POSIXACL(nd.path.dentry->d_inode)) 2574 if (!IS_POSIXACL(nd.path.dentry->d_inode))
2575 mode &= ~current_umask(); 2575 mode &= ~current_umask();
2576 error = mnt_want_write(nd.path.mnt); 2576 error = mnt_want_write(nd.path.mnt);
2577 if (error) 2577 if (error)
2578 goto out_dput; 2578 goto out_dput;
2579 error = security_path_mkdir(&nd.path, dentry, mode); 2579 error = security_path_mkdir(&nd.path, dentry, mode);
2580 if (error) 2580 if (error)
2581 goto out_drop_write; 2581 goto out_drop_write;
2582 error = vfs_mkdir(nd.path.dentry->d_inode, dentry, mode); 2582 error = vfs_mkdir(nd.path.dentry->d_inode, dentry, mode);
2583 out_drop_write: 2583 out_drop_write:
2584 mnt_drop_write(nd.path.mnt); 2584 mnt_drop_write(nd.path.mnt);
2585 out_dput: 2585 out_dput:
2586 dput(dentry); 2586 dput(dentry);
2587 out_unlock: 2587 out_unlock:
2588 mutex_unlock(&nd.path.dentry->d_inode->i_mutex); 2588 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2589 path_put(&nd.path); 2589 path_put(&nd.path);
2590 putname(tmp); 2590 putname(tmp);
2591 out_err: 2591 out_err:
2592 return error; 2592 return error;
2593 } 2593 }
2594 2594
2595 SYSCALL_DEFINE2(mkdir, const char __user *, pathname, int, mode) 2595 SYSCALL_DEFINE2(mkdir, const char __user *, pathname, int, mode)
2596 { 2596 {
2597 return sys_mkdirat(AT_FDCWD, pathname, mode); 2597 return sys_mkdirat(AT_FDCWD, pathname, mode);
2598 } 2598 }
2599 2599
2600 /* 2600 /*
2601 * The dentry_unhash() helper will try to drop the dentry early: we 2601 * The dentry_unhash() helper will try to drop the dentry early: we
2602 * should have a usage count of 2 if we're the only user of this 2602 * should have a usage count of 2 if we're the only user of this
2603 * dentry, and if that is true (possibly after pruning the dcache), 2603 * dentry, and if that is true (possibly after pruning the dcache),
2604 * then we drop the dentry now. 2604 * then we drop the dentry now.
2605 * 2605 *
2606 * A low-level filesystem can, if it choses, legally 2606 * A low-level filesystem can, if it choses, legally
2607 * do a 2607 * do a
2608 * 2608 *
2609 * if (!d_unhashed(dentry)) 2609 * if (!d_unhashed(dentry))
2610 * return -EBUSY; 2610 * return -EBUSY;
2611 * 2611 *
2612 * if it cannot handle the case of removing a directory 2612 * if it cannot handle the case of removing a directory
2613 * that is still in use by something else.. 2613 * that is still in use by something else..
2614 */ 2614 */
2615 void dentry_unhash(struct dentry *dentry) 2615 void dentry_unhash(struct dentry *dentry)
2616 { 2616 {
2617 shrink_dcache_parent(dentry); 2617 shrink_dcache_parent(dentry);
2618 spin_lock(&dentry->d_lock); 2618 spin_lock(&dentry->d_lock);
2619 if (dentry->d_count == 1) 2619 if (dentry->d_count == 1)
2620 __d_drop(dentry); 2620 __d_drop(dentry);
2621 spin_unlock(&dentry->d_lock); 2621 spin_unlock(&dentry->d_lock);
2622 } 2622 }
2623 2623
2624 int vfs_rmdir(struct inode *dir, struct dentry *dentry) 2624 int vfs_rmdir(struct inode *dir, struct dentry *dentry)
2625 { 2625 {
2626 int error = may_delete(dir, dentry, 1); 2626 int error = may_delete(dir, dentry, 1);
2627 2627
2628 if (error) 2628 if (error)
2629 return error; 2629 return error;
2630 2630
2631 if (!dir->i_op->rmdir) 2631 if (!dir->i_op->rmdir)
2632 return -EPERM; 2632 return -EPERM;
2633 2633
2634 mutex_lock(&dentry->d_inode->i_mutex); 2634 mutex_lock(&dentry->d_inode->i_mutex);
2635 2635
2636 error = -EBUSY; 2636 error = -EBUSY;
2637 if (d_mountpoint(dentry)) 2637 if (d_mountpoint(dentry))
2638 goto out; 2638 goto out;
2639 2639
2640 error = security_inode_rmdir(dir, dentry); 2640 error = security_inode_rmdir(dir, dentry);
2641 if (error) 2641 if (error)
2642 goto out; 2642 goto out;
2643 2643
2644 shrink_dcache_parent(dentry); 2644 shrink_dcache_parent(dentry);
2645 error = dir->i_op->rmdir(dir, dentry); 2645 error = dir->i_op->rmdir(dir, dentry);
2646 if (error) 2646 if (error)
2647 goto out; 2647 goto out;
2648 2648
2649 dentry->d_inode->i_flags |= S_DEAD; 2649 dentry->d_inode->i_flags |= S_DEAD;
2650 dont_mount(dentry); 2650 dont_mount(dentry);
2651 2651
2652 out: 2652 out:
2653 mutex_unlock(&dentry->d_inode->i_mutex); 2653 mutex_unlock(&dentry->d_inode->i_mutex);
2654 if (!error) 2654 if (!error)
2655 d_delete(dentry); 2655 d_delete(dentry);
2656 return error; 2656 return error;
2657 } 2657 }
2658 2658
2659 static long do_rmdir(int dfd, const char __user *pathname) 2659 static long do_rmdir(int dfd, const char __user *pathname)
2660 { 2660 {
2661 int error = 0; 2661 int error = 0;
2662 char * name; 2662 char * name;
2663 struct dentry *dentry; 2663 struct dentry *dentry;
2664 struct nameidata nd; 2664 struct nameidata nd;
2665 2665
2666 error = user_path_parent(dfd, pathname, &nd, &name); 2666 error = user_path_parent(dfd, pathname, &nd, &name);
2667 if (error) 2667 if (error)
2668 return error; 2668 return error;
2669 2669
2670 switch(nd.last_type) { 2670 switch(nd.last_type) {
2671 case LAST_DOTDOT: 2671 case LAST_DOTDOT:
2672 error = -ENOTEMPTY; 2672 error = -ENOTEMPTY;
2673 goto exit1; 2673 goto exit1;
2674 case LAST_DOT: 2674 case LAST_DOT:
2675 error = -EINVAL; 2675 error = -EINVAL;
2676 goto exit1; 2676 goto exit1;
2677 case LAST_ROOT: 2677 case LAST_ROOT:
2678 error = -EBUSY; 2678 error = -EBUSY;
2679 goto exit1; 2679 goto exit1;
2680 } 2680 }
2681 2681
2682 nd.flags &= ~LOOKUP_PARENT; 2682 nd.flags &= ~LOOKUP_PARENT;
2683 2683
2684 mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT); 2684 mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2685 dentry = lookup_hash(&nd); 2685 dentry = lookup_hash(&nd);
2686 error = PTR_ERR(dentry); 2686 error = PTR_ERR(dentry);
2687 if (IS_ERR(dentry)) 2687 if (IS_ERR(dentry))
2688 goto exit2; 2688 goto exit2;
2689 if (!dentry->d_inode) { 2689 if (!dentry->d_inode) {
2690 error = -ENOENT; 2690 error = -ENOENT;
2691 goto exit3; 2691 goto exit3;
2692 } 2692 }
2693 error = mnt_want_write(nd.path.mnt); 2693 error = mnt_want_write(nd.path.mnt);
2694 if (error) 2694 if (error)
2695 goto exit3; 2695 goto exit3;
2696 error = security_path_rmdir(&nd.path, dentry); 2696 error = security_path_rmdir(&nd.path, dentry);
2697 if (error) 2697 if (error)
2698 goto exit4; 2698 goto exit4;
2699 error = vfs_rmdir(nd.path.dentry->d_inode, dentry); 2699 error = vfs_rmdir(nd.path.dentry->d_inode, dentry);
2700 exit4: 2700 exit4:
2701 mnt_drop_write(nd.path.mnt); 2701 mnt_drop_write(nd.path.mnt);
2702 exit3: 2702 exit3:
2703 dput(dentry); 2703 dput(dentry);
2704 exit2: 2704 exit2:
2705 mutex_unlock(&nd.path.dentry->d_inode->i_mutex); 2705 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2706 exit1: 2706 exit1:
2707 path_put(&nd.path); 2707 path_put(&nd.path);
2708 putname(name); 2708 putname(name);
2709 return error; 2709 return error;
2710 } 2710 }
2711 2711
2712 SYSCALL_DEFINE1(rmdir, const char __user *, pathname) 2712 SYSCALL_DEFINE1(rmdir, const char __user *, pathname)
2713 { 2713 {
2714 return do_rmdir(AT_FDCWD, pathname); 2714 return do_rmdir(AT_FDCWD, pathname);
2715 } 2715 }
2716 2716
2717 int vfs_unlink(struct inode *dir, struct dentry *dentry) 2717 int vfs_unlink(struct inode *dir, struct dentry *dentry)
2718 { 2718 {
2719 int error = may_delete(dir, dentry, 0); 2719 int error = may_delete(dir, dentry, 0);
2720 2720
2721 if (error) 2721 if (error)
2722 return error; 2722 return error;
2723 2723
2724 if (!dir->i_op->unlink) 2724 if (!dir->i_op->unlink)
2725 return -EPERM; 2725 return -EPERM;
2726 2726
2727 mutex_lock(&dentry->d_inode->i_mutex); 2727 mutex_lock(&dentry->d_inode->i_mutex);
2728 if (d_mountpoint(dentry)) 2728 if (d_mountpoint(dentry))
2729 error = -EBUSY; 2729 error = -EBUSY;
2730 else { 2730 else {
2731 error = security_inode_unlink(dir, dentry); 2731 error = security_inode_unlink(dir, dentry);
2732 if (!error) { 2732 if (!error) {
2733 error = dir->i_op->unlink(dir, dentry); 2733 error = dir->i_op->unlink(dir, dentry);
2734 if (!error) 2734 if (!error)
2735 dont_mount(dentry); 2735 dont_mount(dentry);
2736 } 2736 }
2737 } 2737 }
2738 mutex_unlock(&dentry->d_inode->i_mutex); 2738 mutex_unlock(&dentry->d_inode->i_mutex);
2739 2739
2740 /* We don't d_delete() NFS sillyrenamed files--they still exist. */ 2740 /* We don't d_delete() NFS sillyrenamed files--they still exist. */
2741 if (!error && !(dentry->d_flags & DCACHE_NFSFS_RENAMED)) { 2741 if (!error && !(dentry->d_flags & DCACHE_NFSFS_RENAMED)) {
2742 fsnotify_link_count(dentry->d_inode); 2742 fsnotify_link_count(dentry->d_inode);
2743 d_delete(dentry); 2743 d_delete(dentry);
2744 } 2744 }
2745 2745
2746 return error; 2746 return error;
2747 } 2747 }
2748 2748
2749 /* 2749 /*
2750 * Make sure that the actual truncation of the file will occur outside its 2750 * Make sure that the actual truncation of the file will occur outside its
2751 * directory's i_mutex. Truncate can take a long time if there is a lot of 2751 * directory's i_mutex. Truncate can take a long time if there is a lot of
2752 * writeout happening, and we don't want to prevent access to the directory 2752 * writeout happening, and we don't want to prevent access to the directory
2753 * while waiting on the I/O. 2753 * while waiting on the I/O.
2754 */ 2754 */
2755 static long do_unlinkat(int dfd, const char __user *pathname) 2755 static long do_unlinkat(int dfd, const char __user *pathname)
2756 { 2756 {
2757 int error; 2757 int error;
2758 char *name; 2758 char *name;
2759 struct dentry *dentry; 2759 struct dentry *dentry;
2760 struct nameidata nd; 2760 struct nameidata nd;
2761 struct inode *inode = NULL; 2761 struct inode *inode = NULL;
2762 2762
2763 error = user_path_parent(dfd, pathname, &nd, &name); 2763 error = user_path_parent(dfd, pathname, &nd, &name);
2764 if (error) 2764 if (error)
2765 return error; 2765 return error;
2766 2766
2767 error = -EISDIR; 2767 error = -EISDIR;
2768 if (nd.last_type != LAST_NORM) 2768 if (nd.last_type != LAST_NORM)
2769 goto exit1; 2769 goto exit1;
2770 2770
2771 nd.flags &= ~LOOKUP_PARENT; 2771 nd.flags &= ~LOOKUP_PARENT;
2772 2772
2773 mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT); 2773 mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2774 dentry = lookup_hash(&nd); 2774 dentry = lookup_hash(&nd);
2775 error = PTR_ERR(dentry); 2775 error = PTR_ERR(dentry);
2776 if (!IS_ERR(dentry)) { 2776 if (!IS_ERR(dentry)) {
2777 /* Why not before? Because we want correct error value */ 2777 /* Why not before? Because we want correct error value */
2778 if (nd.last.name[nd.last.len]) 2778 if (nd.last.name[nd.last.len])
2779 goto slashes; 2779 goto slashes;
2780 inode = dentry->d_inode; 2780 inode = dentry->d_inode;
2781 if (!inode) 2781 if (!inode)
2782 goto slashes; 2782 goto slashes;
2783 ihold(inode); 2783 ihold(inode);
2784 error = mnt_want_write(nd.path.mnt); 2784 error = mnt_want_write(nd.path.mnt);
2785 if (error) 2785 if (error)
2786 goto exit2; 2786 goto exit2;
2787 error = security_path_unlink(&nd.path, dentry); 2787 error = security_path_unlink(&nd.path, dentry);
2788 if (error) 2788 if (error)
2789 goto exit3; 2789 goto exit3;
2790 error = vfs_unlink(nd.path.dentry->d_inode, dentry); 2790 error = vfs_unlink(nd.path.dentry->d_inode, dentry);
2791 exit3: 2791 exit3:
2792 mnt_drop_write(nd.path.mnt); 2792 mnt_drop_write(nd.path.mnt);
2793 exit2: 2793 exit2:
2794 dput(dentry); 2794 dput(dentry);
2795 } 2795 }
2796 mutex_unlock(&nd.path.dentry->d_inode->i_mutex); 2796 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2797 if (inode) 2797 if (inode)
2798 iput(inode); /* truncate the inode here */ 2798 iput(inode); /* truncate the inode here */
2799 exit1: 2799 exit1:
2800 path_put(&nd.path); 2800 path_put(&nd.path);
2801 putname(name); 2801 putname(name);
2802 return error; 2802 return error;
2803 2803
2804 slashes: 2804 slashes:
2805 error = !dentry->d_inode ? -ENOENT : 2805 error = !dentry->d_inode ? -ENOENT :
2806 S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR; 2806 S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR;
2807 goto exit2; 2807 goto exit2;
2808 } 2808 }
2809 2809
2810 SYSCALL_DEFINE3(unlinkat, int, dfd, const char __user *, pathname, int, flag) 2810 SYSCALL_DEFINE3(unlinkat, int, dfd, const char __user *, pathname, int, flag)
2811 { 2811 {
2812 if ((flag & ~AT_REMOVEDIR) != 0) 2812 if ((flag & ~AT_REMOVEDIR) != 0)
2813 return -EINVAL; 2813 return -EINVAL;
2814 2814
2815 if (flag & AT_REMOVEDIR) 2815 if (flag & AT_REMOVEDIR)
2816 return do_rmdir(dfd, pathname); 2816 return do_rmdir(dfd, pathname);
2817 2817
2818 return do_unlinkat(dfd, pathname); 2818 return do_unlinkat(dfd, pathname);
2819 } 2819 }
2820 2820
2821 SYSCALL_DEFINE1(unlink, const char __user *, pathname) 2821 SYSCALL_DEFINE1(unlink, const char __user *, pathname)
2822 { 2822 {
2823 return do_unlinkat(AT_FDCWD, pathname); 2823 return do_unlinkat(AT_FDCWD, pathname);
2824 } 2824 }
2825 2825
2826 int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname) 2826 int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname)
2827 { 2827 {
2828 int error = may_create(dir, dentry); 2828 int error = may_create(dir, dentry);
2829 2829
2830 if (error) 2830 if (error)
2831 return error; 2831 return error;
2832 2832
2833 if (!dir->i_op->symlink) 2833 if (!dir->i_op->symlink)
2834 return -EPERM; 2834 return -EPERM;
2835 2835
2836 error = security_inode_symlink(dir, dentry, oldname); 2836 error = security_inode_symlink(dir, dentry, oldname);
2837 if (error) 2837 if (error)
2838 return error; 2838 return error;
2839 2839
2840 error = dir->i_op->symlink(dir, dentry, oldname); 2840 error = dir->i_op->symlink(dir, dentry, oldname);
2841 if (!error) 2841 if (!error)
2842 fsnotify_create(dir, dentry); 2842 fsnotify_create(dir, dentry);
2843 return error; 2843 return error;
2844 } 2844 }
2845 2845
2846 SYSCALL_DEFINE3(symlinkat, const char __user *, oldname, 2846 SYSCALL_DEFINE3(symlinkat, const char __user *, oldname,
2847 int, newdfd, const char __user *, newname) 2847 int, newdfd, const char __user *, newname)
2848 { 2848 {
2849 int error; 2849 int error;
2850 char *from; 2850 char *from;
2851 char *to; 2851 char *to;
2852 struct dentry *dentry; 2852 struct dentry *dentry;
2853 struct nameidata nd; 2853 struct nameidata nd;
2854 2854
2855 from = getname(oldname); 2855 from = getname(oldname);
2856 if (IS_ERR(from)) 2856 if (IS_ERR(from))
2857 return PTR_ERR(from); 2857 return PTR_ERR(from);
2858 2858
2859 error = user_path_parent(newdfd, newname, &nd, &to); 2859 error = user_path_parent(newdfd, newname, &nd, &to);
2860 if (error) 2860 if (error)
2861 goto out_putname; 2861 goto out_putname;
2862 2862
2863 dentry = lookup_create(&nd, 0); 2863 dentry = lookup_create(&nd, 0);
2864 error = PTR_ERR(dentry); 2864 error = PTR_ERR(dentry);
2865 if (IS_ERR(dentry)) 2865 if (IS_ERR(dentry))
2866 goto out_unlock; 2866 goto out_unlock;
2867 2867
2868 error = mnt_want_write(nd.path.mnt); 2868 error = mnt_want_write(nd.path.mnt);
2869 if (error) 2869 if (error)
2870 goto out_dput; 2870 goto out_dput;
2871 error = security_path_symlink(&nd.path, dentry, from); 2871 error = security_path_symlink(&nd.path, dentry, from);
2872 if (error) 2872 if (error)
2873 goto out_drop_write; 2873 goto out_drop_write;
2874 error = vfs_symlink(nd.path.dentry->d_inode, dentry, from); 2874 error = vfs_symlink(nd.path.dentry->d_inode, dentry, from);
2875 out_drop_write: 2875 out_drop_write:
2876 mnt_drop_write(nd.path.mnt); 2876 mnt_drop_write(nd.path.mnt);
2877 out_dput: 2877 out_dput:
2878 dput(dentry); 2878 dput(dentry);
2879 out_unlock: 2879 out_unlock:
2880 mutex_unlock(&nd.path.dentry->d_inode->i_mutex); 2880 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2881 path_put(&nd.path); 2881 path_put(&nd.path);
2882 putname(to); 2882 putname(to);
2883 out_putname: 2883 out_putname:
2884 putname(from); 2884 putname(from);
2885 return error; 2885 return error;
2886 } 2886 }
2887 2887
2888 SYSCALL_DEFINE2(symlink, const char __user *, oldname, const char __user *, newname) 2888 SYSCALL_DEFINE2(symlink, const char __user *, oldname, const char __user *, newname)
2889 { 2889 {
2890 return sys_symlinkat(oldname, AT_FDCWD, newname); 2890 return sys_symlinkat(oldname, AT_FDCWD, newname);
2891 } 2891 }
2892 2892
2893 int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry) 2893 int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry)
2894 { 2894 {
2895 struct inode *inode = old_dentry->d_inode; 2895 struct inode *inode = old_dentry->d_inode;
2896 int error; 2896 int error;
2897 2897
2898 if (!inode) 2898 if (!inode)
2899 return -ENOENT; 2899 return -ENOENT;
2900 2900
2901 error = may_create(dir, new_dentry); 2901 error = may_create(dir, new_dentry);
2902 if (error) 2902 if (error)
2903 return error; 2903 return error;
2904 2904
2905 if (dir->i_sb != inode->i_sb) 2905 if (dir->i_sb != inode->i_sb)
2906 return -EXDEV; 2906 return -EXDEV;
2907 2907
2908 /* 2908 /*
2909 * A link to an append-only or immutable file cannot be created. 2909 * A link to an append-only or immutable file cannot be created.
2910 */ 2910 */
2911 if (IS_APPEND(inode) || IS_IMMUTABLE(inode)) 2911 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
2912 return -EPERM; 2912 return -EPERM;
2913 if (!dir->i_op->link) 2913 if (!dir->i_op->link)
2914 return -EPERM; 2914 return -EPERM;
2915 if (S_ISDIR(inode->i_mode)) 2915 if (S_ISDIR(inode->i_mode))
2916 return -EPERM; 2916 return -EPERM;
2917 2917
2918 error = security_inode_link(old_dentry, dir, new_dentry); 2918 error = security_inode_link(old_dentry, dir, new_dentry);
2919 if (error) 2919 if (error)
2920 return error; 2920 return error;
2921 2921
2922 mutex_lock(&inode->i_mutex); 2922 mutex_lock(&inode->i_mutex);
2923 /* Make sure we don't allow creating hardlink to an unlinked file */ 2923 /* Make sure we don't allow creating hardlink to an unlinked file */
2924 if (inode->i_nlink == 0) 2924 if (inode->i_nlink == 0)
2925 error = -ENOENT; 2925 error = -ENOENT;
2926 else 2926 else
2927 error = dir->i_op->link(old_dentry, dir, new_dentry); 2927 error = dir->i_op->link(old_dentry, dir, new_dentry);
2928 mutex_unlock(&inode->i_mutex); 2928 mutex_unlock(&inode->i_mutex);
2929 if (!error) 2929 if (!error)
2930 fsnotify_link(dir, inode, new_dentry); 2930 fsnotify_link(dir, inode, new_dentry);
2931 return error; 2931 return error;
2932 } 2932 }
2933 2933
2934 /* 2934 /*
2935 * Hardlinks are often used in delicate situations. We avoid 2935 * Hardlinks are often used in delicate situations. We avoid
2936 * security-related surprises by not following symlinks on the 2936 * security-related surprises by not following symlinks on the
2937 * newname. --KAB 2937 * newname. --KAB
2938 * 2938 *
2939 * We don't follow them on the oldname either to be compatible 2939 * We don't follow them on the oldname either to be compatible
2940 * with linux 2.0, and to avoid hard-linking to directories 2940 * with linux 2.0, and to avoid hard-linking to directories
2941 * and other special files. --ADM 2941 * and other special files. --ADM
2942 */ 2942 */
2943 SYSCALL_DEFINE5(linkat, int, olddfd, const char __user *, oldname, 2943 SYSCALL_DEFINE5(linkat, int, olddfd, const char __user *, oldname,
2944 int, newdfd, const char __user *, newname, int, flags) 2944 int, newdfd, const char __user *, newname, int, flags)
2945 { 2945 {
2946 struct dentry *new_dentry; 2946 struct dentry *new_dentry;
2947 struct nameidata nd; 2947 struct nameidata nd;
2948 struct path old_path; 2948 struct path old_path;
2949 int how = 0; 2949 int how = 0;
2950 int error; 2950 int error;
2951 char *to; 2951 char *to;
2952 2952
2953 if ((flags & ~(AT_SYMLINK_FOLLOW | AT_EMPTY_PATH)) != 0) 2953 if ((flags & ~(AT_SYMLINK_FOLLOW | AT_EMPTY_PATH)) != 0)
2954 return -EINVAL; 2954 return -EINVAL;
2955 /* 2955 /*
2956 * To use null names we require CAP_DAC_READ_SEARCH 2956 * To use null names we require CAP_DAC_READ_SEARCH
2957 * This ensures that not everyone will be able to create 2957 * This ensures that not everyone will be able to create
2958 * handlink using the passed filedescriptor. 2958 * handlink using the passed filedescriptor.
2959 */ 2959 */
2960 if (flags & AT_EMPTY_PATH) { 2960 if (flags & AT_EMPTY_PATH) {
2961 if (!capable(CAP_DAC_READ_SEARCH)) 2961 if (!capable(CAP_DAC_READ_SEARCH))
2962 return -ENOENT; 2962 return -ENOENT;
2963 how = LOOKUP_EMPTY; 2963 how = LOOKUP_EMPTY;
2964 } 2964 }
2965 2965
2966 if (flags & AT_SYMLINK_FOLLOW) 2966 if (flags & AT_SYMLINK_FOLLOW)
2967 how |= LOOKUP_FOLLOW; 2967 how |= LOOKUP_FOLLOW;
2968 2968
2969 error = user_path_at(olddfd, oldname, how, &old_path); 2969 error = user_path_at(olddfd, oldname, how, &old_path);
2970 if (error) 2970 if (error)
2971 return error; 2971 return error;
2972 2972
2973 error = user_path_parent(newdfd, newname, &nd, &to); 2973 error = user_path_parent(newdfd, newname, &nd, &to);
2974 if (error) 2974 if (error)
2975 goto out; 2975 goto out;
2976 error = -EXDEV; 2976 error = -EXDEV;
2977 if (old_path.mnt != nd.path.mnt) 2977 if (old_path.mnt != nd.path.mnt)
2978 goto out_release; 2978 goto out_release;
2979 new_dentry = lookup_create(&nd, 0); 2979 new_dentry = lookup_create(&nd, 0);
2980 error = PTR_ERR(new_dentry); 2980 error = PTR_ERR(new_dentry);
2981 if (IS_ERR(new_dentry)) 2981 if (IS_ERR(new_dentry))
2982 goto out_unlock; 2982 goto out_unlock;
2983 error = mnt_want_write(nd.path.mnt); 2983 error = mnt_want_write(nd.path.mnt);
2984 if (error) 2984 if (error)
2985 goto out_dput; 2985 goto out_dput;
2986 error = security_path_link(old_path.dentry, &nd.path, new_dentry); 2986 error = security_path_link(old_path.dentry, &nd.path, new_dentry);
2987 if (error) 2987 if (error)
2988 goto out_drop_write; 2988 goto out_drop_write;
2989 error = vfs_link(old_path.dentry, nd.path.dentry->d_inode, new_dentry); 2989 error = vfs_link(old_path.dentry, nd.path.dentry->d_inode, new_dentry);
2990 out_drop_write: 2990 out_drop_write:
2991 mnt_drop_write(nd.path.mnt); 2991 mnt_drop_write(nd.path.mnt);
2992 out_dput: 2992 out_dput:
2993 dput(new_dentry); 2993 dput(new_dentry);
2994 out_unlock: 2994 out_unlock:
2995 mutex_unlock(&nd.path.dentry->d_inode->i_mutex); 2995 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2996 out_release: 2996 out_release:
2997 path_put(&nd.path); 2997 path_put(&nd.path);
2998 putname(to); 2998 putname(to);
2999 out: 2999 out:
3000 path_put(&old_path); 3000 path_put(&old_path);
3001 3001
3002 return error; 3002 return error;
3003 } 3003 }
3004 3004
3005 SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newname) 3005 SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newname)
3006 { 3006 {
3007 return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0); 3007 return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0);
3008 } 3008 }
3009 3009
3010 /* 3010 /*
3011 * The worst of all namespace operations - renaming directory. "Perverted" 3011 * The worst of all namespace operations - renaming directory. "Perverted"
3012 * doesn't even start to describe it. Somebody in UCB had a heck of a trip... 3012 * doesn't even start to describe it. Somebody in UCB had a heck of a trip...
3013 * Problems: 3013 * Problems:
3014 * a) we can get into loop creation. Check is done in is_subdir(). 3014 * a) we can get into loop creation. Check is done in is_subdir().
3015 * b) race potential - two innocent renames can create a loop together. 3015 * b) race potential - two innocent renames can create a loop together.
3016 * That's where 4.4 screws up. Current fix: serialization on 3016 * That's where 4.4 screws up. Current fix: serialization on
3017 * sb->s_vfs_rename_mutex. We might be more accurate, but that's another 3017 * sb->s_vfs_rename_mutex. We might be more accurate, but that's another
3018 * story. 3018 * story.
3019 * c) we have to lock _three_ objects - parents and victim (if it exists). 3019 * c) we have to lock _three_ objects - parents and victim (if it exists).
3020 * And that - after we got ->i_mutex on parents (until then we don't know 3020 * And that - after we got ->i_mutex on parents (until then we don't know
3021 * whether the target exists). Solution: try to be smart with locking 3021 * whether the target exists). Solution: try to be smart with locking
3022 * order for inodes. We rely on the fact that tree topology may change 3022 * order for inodes. We rely on the fact that tree topology may change
3023 * only under ->s_vfs_rename_mutex _and_ that parent of the object we 3023 * only under ->s_vfs_rename_mutex _and_ that parent of the object we
3024 * move will be locked. Thus we can rank directories by the tree 3024 * move will be locked. Thus we can rank directories by the tree
3025 * (ancestors first) and rank all non-directories after them. 3025 * (ancestors first) and rank all non-directories after them.
3026 * That works since everybody except rename does "lock parent, lookup, 3026 * That works since everybody except rename does "lock parent, lookup,
3027 * lock child" and rename is under ->s_vfs_rename_mutex. 3027 * lock child" and rename is under ->s_vfs_rename_mutex.
3028 * HOWEVER, it relies on the assumption that any object with ->lookup() 3028 * HOWEVER, it relies on the assumption that any object with ->lookup()
3029 * has no more than 1 dentry. If "hybrid" objects will ever appear, 3029 * has no more than 1 dentry. If "hybrid" objects will ever appear,
3030 * we'd better make sure that there's no link(2) for them. 3030 * we'd better make sure that there's no link(2) for them.
3031 * d) conversion from fhandle to dentry may come in the wrong moment - when 3031 * d) conversion from fhandle to dentry may come in the wrong moment - when
3032 * we are removing the target. Solution: we will have to grab ->i_mutex 3032 * we are removing the target. Solution: we will have to grab ->i_mutex
3033 * in the fhandle_to_dentry code. [FIXME - current nfsfh.c relies on 3033 * in the fhandle_to_dentry code. [FIXME - current nfsfh.c relies on
3034 * ->i_mutex on parents, which works but leads to some truly excessive 3034 * ->i_mutex on parents, which works but leads to some truly excessive
3035 * locking]. 3035 * locking].
3036 */ 3036 */
3037 static int vfs_rename_dir(struct inode *old_dir, struct dentry *old_dentry, 3037 static int vfs_rename_dir(struct inode *old_dir, struct dentry *old_dentry,
3038 struct inode *new_dir, struct dentry *new_dentry) 3038 struct inode *new_dir, struct dentry *new_dentry)
3039 { 3039 {
3040 int error = 0; 3040 int error = 0;
3041 struct inode *target = new_dentry->d_inode; 3041 struct inode *target = new_dentry->d_inode;
3042 3042
3043 /* 3043 /*
3044 * If we are going to change the parent - check write permissions, 3044 * If we are going to change the parent - check write permissions,
3045 * we'll need to flip '..'. 3045 * we'll need to flip '..'.
3046 */ 3046 */
3047 if (new_dir != old_dir) { 3047 if (new_dir != old_dir) {
3048 error = inode_permission(old_dentry->d_inode, MAY_WRITE); 3048 error = inode_permission(old_dentry->d_inode, MAY_WRITE);
3049 if (error) 3049 if (error)
3050 return error; 3050 return error;
3051 } 3051 }
3052 3052
3053 error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry); 3053 error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
3054 if (error) 3054 if (error)
3055 return error; 3055 return error;
3056 3056
3057 if (target) 3057 if (target)
3058 mutex_lock(&target->i_mutex); 3058 mutex_lock(&target->i_mutex);
3059 3059
3060 error = -EBUSY; 3060 error = -EBUSY;
3061 if (d_mountpoint(old_dentry) || d_mountpoint(new_dentry)) 3061 if (d_mountpoint(old_dentry) || d_mountpoint(new_dentry))
3062 goto out; 3062 goto out;
3063 3063
3064 if (target) 3064 if (target)
3065 shrink_dcache_parent(new_dentry); 3065 shrink_dcache_parent(new_dentry);
3066 error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry); 3066 error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
3067 if (error) 3067 if (error)
3068 goto out; 3068 goto out;
3069 3069
3070 if (target) { 3070 if (target) {
3071 target->i_flags |= S_DEAD; 3071 target->i_flags |= S_DEAD;
3072 dont_mount(new_dentry); 3072 dont_mount(new_dentry);
3073 } 3073 }
3074 out: 3074 out:
3075 if (target) 3075 if (target)
3076 mutex_unlock(&target->i_mutex); 3076 mutex_unlock(&target->i_mutex);
3077 if (!error) 3077 if (!error)
3078 if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE)) 3078 if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
3079 d_move(old_dentry,new_dentry); 3079 d_move(old_dentry,new_dentry);
3080 return error; 3080 return error;
3081 } 3081 }
3082 3082
3083 static int vfs_rename_other(struct inode *old_dir, struct dentry *old_dentry, 3083 static int vfs_rename_other(struct inode *old_dir, struct dentry *old_dentry,
3084 struct inode *new_dir, struct dentry *new_dentry) 3084 struct inode *new_dir, struct dentry *new_dentry)
3085 { 3085 {
3086 struct inode *target = new_dentry->d_inode; 3086 struct inode *target = new_dentry->d_inode;
3087 int error; 3087 int error;
3088 3088
3089 error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry); 3089 error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
3090 if (error) 3090 if (error)
3091 return error; 3091 return error;
3092 3092
3093 dget(new_dentry); 3093 dget(new_dentry);
3094 if (target) 3094 if (target)
3095 mutex_lock(&target->i_mutex); 3095 mutex_lock(&target->i_mutex);
3096 3096
3097 error = -EBUSY; 3097 error = -EBUSY;
3098 if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry)) 3098 if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry))
3099 goto out; 3099 goto out;
3100 3100
3101 error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry); 3101 error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
3102 if (error) 3102 if (error)
3103 goto out; 3103 goto out;
3104 3104
3105 if (target) 3105 if (target)
3106 dont_mount(new_dentry); 3106 dont_mount(new_dentry);
3107 if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE)) 3107 if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
3108 d_move(old_dentry, new_dentry); 3108 d_move(old_dentry, new_dentry);
3109 out: 3109 out:
3110 if (target) 3110 if (target)
3111 mutex_unlock(&target->i_mutex); 3111 mutex_unlock(&target->i_mutex);
3112 dput(new_dentry); 3112 dput(new_dentry);
3113 return error; 3113 return error;
3114 } 3114 }
3115 3115
3116 int vfs_rename(struct inode *old_dir, struct dentry *old_dentry, 3116 int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
3117 struct inode *new_dir, struct dentry *new_dentry) 3117 struct inode *new_dir, struct dentry *new_dentry)
3118 { 3118 {
3119 int error; 3119 int error;
3120 int is_dir = S_ISDIR(old_dentry->d_inode->i_mode); 3120 int is_dir = S_ISDIR(old_dentry->d_inode->i_mode);
3121 const unsigned char *old_name; 3121 const unsigned char *old_name;
3122 3122
3123 if (old_dentry->d_inode == new_dentry->d_inode) 3123 if (old_dentry->d_inode == new_dentry->d_inode)
3124 return 0; 3124 return 0;
3125 3125
3126 error = may_delete(old_dir, old_dentry, is_dir); 3126 error = may_delete(old_dir, old_dentry, is_dir);
3127 if (error) 3127 if (error)
3128 return error; 3128 return error;
3129 3129
3130 if (!new_dentry->d_inode) 3130 if (!new_dentry->d_inode)
3131 error = may_create(new_dir, new_dentry); 3131 error = may_create(new_dir, new_dentry);
3132 else 3132 else
3133 error = may_delete(new_dir, new_dentry, is_dir); 3133 error = may_delete(new_dir, new_dentry, is_dir);
3134 if (error) 3134 if (error)
3135 return error; 3135 return error;
3136 3136
3137 if (!old_dir->i_op->rename) 3137 if (!old_dir->i_op->rename)
3138 return -EPERM; 3138 return -EPERM;
3139 3139
3140 old_name = fsnotify_oldname_init(old_dentry->d_name.name); 3140 old_name = fsnotify_oldname_init(old_dentry->d_name.name);
3141 3141
3142 if (is_dir) 3142 if (is_dir)
3143 error = vfs_rename_dir(old_dir,old_dentry,new_dir,new_dentry); 3143 error = vfs_rename_dir(old_dir,old_dentry,new_dir,new_dentry);
3144 else 3144 else
3145 error = vfs_rename_other(old_dir,old_dentry,new_dir,new_dentry); 3145 error = vfs_rename_other(old_dir,old_dentry,new_dir,new_dentry);
3146 if (!error) 3146 if (!error)
3147 fsnotify_move(old_dir, new_dir, old_name, is_dir, 3147 fsnotify_move(old_dir, new_dir, old_name, is_dir,
3148 new_dentry->d_inode, old_dentry); 3148 new_dentry->d_inode, old_dentry);
3149 fsnotify_oldname_free(old_name); 3149 fsnotify_oldname_free(old_name);
3150 3150
3151 return error; 3151 return error;
3152 } 3152 }
3153 3153
3154 SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname, 3154 SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
3155 int, newdfd, const char __user *, newname) 3155 int, newdfd, const char __user *, newname)
3156 { 3156 {
3157 struct dentry *old_dir, *new_dir; 3157 struct dentry *old_dir, *new_dir;
3158 struct dentry *old_dentry, *new_dentry; 3158 struct dentry *old_dentry, *new_dentry;
3159 struct dentry *trap; 3159 struct dentry *trap;
3160 struct nameidata oldnd, newnd; 3160 struct nameidata oldnd, newnd;
3161 char *from; 3161 char *from;
3162 char *to; 3162 char *to;
3163 int error; 3163 int error;
3164 3164
3165 error = user_path_parent(olddfd, oldname, &oldnd, &from); 3165 error = user_path_parent(olddfd, oldname, &oldnd, &from);
3166 if (error) 3166 if (error)
3167 goto exit; 3167 goto exit;
3168 3168
3169 error = user_path_parent(newdfd, newname, &newnd, &to); 3169 error = user_path_parent(newdfd, newname, &newnd, &to);
3170 if (error) 3170 if (error)
3171 goto exit1; 3171 goto exit1;
3172 3172
3173 error = -EXDEV; 3173 error = -EXDEV;
3174 if (oldnd.path.mnt != newnd.path.mnt) 3174 if (oldnd.path.mnt != newnd.path.mnt)
3175 goto exit2; 3175 goto exit2;
3176 3176
3177 old_dir = oldnd.path.dentry; 3177 old_dir = oldnd.path.dentry;
3178 error = -EBUSY; 3178 error = -EBUSY;
3179 if (oldnd.last_type != LAST_NORM) 3179 if (oldnd.last_type != LAST_NORM)
3180 goto exit2; 3180 goto exit2;
3181 3181
3182 new_dir = newnd.path.dentry; 3182 new_dir = newnd.path.dentry;
3183 if (newnd.last_type != LAST_NORM) 3183 if (newnd.last_type != LAST_NORM)
3184 goto exit2; 3184 goto exit2;
3185 3185
3186 oldnd.flags &= ~LOOKUP_PARENT; 3186 oldnd.flags &= ~LOOKUP_PARENT;
3187 newnd.flags &= ~LOOKUP_PARENT; 3187 newnd.flags &= ~LOOKUP_PARENT;
3188 newnd.flags |= LOOKUP_RENAME_TARGET; 3188 newnd.flags |= LOOKUP_RENAME_TARGET;
3189 3189
3190 trap = lock_rename(new_dir, old_dir); 3190 trap = lock_rename(new_dir, old_dir);
3191 3191
3192 old_dentry = lookup_hash(&oldnd); 3192 old_dentry = lookup_hash(&oldnd);
3193 error = PTR_ERR(old_dentry); 3193 error = PTR_ERR(old_dentry);
3194 if (IS_ERR(old_dentry)) 3194 if (IS_ERR(old_dentry))
3195 goto exit3; 3195 goto exit3;
3196 /* source must exist */ 3196 /* source must exist */
3197 error = -ENOENT; 3197 error = -ENOENT;
3198 if (!old_dentry->d_inode) 3198 if (!old_dentry->d_inode)
3199 goto exit4; 3199 goto exit4;
3200 /* unless the source is a directory trailing slashes give -ENOTDIR */ 3200 /* unless the source is a directory trailing slashes give -ENOTDIR */
3201 if (!S_ISDIR(old_dentry->d_inode->i_mode)) { 3201 if (!S_ISDIR(old_dentry->d_inode->i_mode)) {
3202 error = -ENOTDIR; 3202 error = -ENOTDIR;
3203 if (oldnd.last.name[oldnd.last.len]) 3203 if (oldnd.last.name[oldnd.last.len])
3204 goto exit4; 3204 goto exit4;
3205 if (newnd.last.name[newnd.last.len]) 3205 if (newnd.last.name[newnd.last.len])
3206 goto exit4; 3206 goto exit4;
3207 } 3207 }
3208 /* source should not be ancestor of target */ 3208 /* source should not be ancestor of target */
3209 error = -EINVAL; 3209 error = -EINVAL;
3210 if (old_dentry == trap) 3210 if (old_dentry == trap)
3211 goto exit4; 3211 goto exit4;
3212 new_dentry = lookup_hash(&newnd); 3212 new_dentry = lookup_hash(&newnd);
3213 error = PTR_ERR(new_dentry); 3213 error = PTR_ERR(new_dentry);
3214 if (IS_ERR(new_dentry)) 3214 if (IS_ERR(new_dentry))
3215 goto exit4; 3215 goto exit4;
3216 /* target should not be an ancestor of source */ 3216 /* target should not be an ancestor of source */
3217 error = -ENOTEMPTY; 3217 error = -ENOTEMPTY;
3218 if (new_dentry == trap) 3218 if (new_dentry == trap)
3219 goto exit5; 3219 goto exit5;
3220 3220
3221 error = mnt_want_write(oldnd.path.mnt); 3221 error = mnt_want_write(oldnd.path.mnt);
3222 if (error) 3222 if (error)
3223 goto exit5; 3223 goto exit5;
3224 error = security_path_rename(&oldnd.path, old_dentry, 3224 error = security_path_rename(&oldnd.path, old_dentry,
3225 &newnd.path, new_dentry); 3225 &newnd.path, new_dentry);
3226 if (error) 3226 if (error)
3227 goto exit6; 3227 goto exit6;
3228 error = vfs_rename(old_dir->d_inode, old_dentry, 3228 error = vfs_rename(old_dir->d_inode, old_dentry,
3229 new_dir->d_inode, new_dentry); 3229 new_dir->d_inode, new_dentry);
3230 exit6: 3230 exit6:
3231 mnt_drop_write(oldnd.path.mnt); 3231 mnt_drop_write(oldnd.path.mnt);
3232 exit5: 3232 exit5:
3233 dput(new_dentry); 3233 dput(new_dentry);
3234 exit4: 3234 exit4:
3235 dput(old_dentry); 3235 dput(old_dentry);
3236 exit3: 3236 exit3:
3237 unlock_rename(new_dir, old_dir); 3237 unlock_rename(new_dir, old_dir);
3238 exit2: 3238 exit2:
3239 path_put(&newnd.path); 3239 path_put(&newnd.path);
3240 putname(to); 3240 putname(to);
3241 exit1: 3241 exit1:
3242 path_put(&oldnd.path); 3242 path_put(&oldnd.path);
3243 putname(from); 3243 putname(from);
3244 exit: 3244 exit:
3245 return error; 3245 return error;
3246 } 3246 }
3247 3247
3248 SYSCALL_DEFINE2(rename, const char __user *, oldname, const char __user *, newname) 3248 SYSCALL_DEFINE2(rename, const char __user *, oldname, const char __user *, newname)
3249 { 3249 {
3250 return sys_renameat(AT_FDCWD, oldname, AT_FDCWD, newname); 3250 return sys_renameat(AT_FDCWD, oldname, AT_FDCWD, newname);
3251 } 3251 }
3252 3252
3253 int vfs_readlink(struct dentry *dentry, char __user *buffer, int buflen, const char *link) 3253 int vfs_readlink(struct dentry *dentry, char __user *buffer, int buflen, const char *link)
3254 { 3254 {
3255 int len; 3255 int len;
3256 3256
3257 len = PTR_ERR(link); 3257 len = PTR_ERR(link);
3258 if (IS_ERR(link)) 3258 if (IS_ERR(link))
3259 goto out; 3259 goto out;
3260 3260
3261 len = strlen(link); 3261 len = strlen(link);
3262 if (len > (unsigned) buflen) 3262 if (len > (unsigned) buflen)
3263 len = buflen; 3263 len = buflen;
3264 if (copy_to_user(buffer, link, len)) 3264 if (copy_to_user(buffer, link, len))
3265 len = -EFAULT; 3265 len = -EFAULT;
3266 out: 3266 out:
3267 return len; 3267 return len;
3268 } 3268 }
3269 3269
3270 /* 3270 /*
3271 * A helper for ->readlink(). This should be used *ONLY* for symlinks that 3271 * A helper for ->readlink(). This should be used *ONLY* for symlinks that
3272 * have ->follow_link() touching nd only in nd_set_link(). Using (or not 3272 * have ->follow_link() touching nd only in nd_set_link(). Using (or not
3273 * using) it for any given inode is up to filesystem. 3273 * using) it for any given inode is up to filesystem.
3274 */ 3274 */
3275 int generic_readlink(struct dentry *dentry, char __user *buffer, int buflen) 3275 int generic_readlink(struct dentry *dentry, char __user *buffer, int buflen)
3276 { 3276 {
3277 struct nameidata nd; 3277 struct nameidata nd;
3278 void *cookie; 3278 void *cookie;
3279 int res; 3279 int res;
3280 3280
3281 nd.depth = 0; 3281 nd.depth = 0;
3282 cookie = dentry->d_inode->i_op->follow_link(dentry, &nd); 3282 cookie = dentry->d_inode->i_op->follow_link(dentry, &nd);
3283 if (IS_ERR(cookie)) 3283 if (IS_ERR(cookie))
3284 return PTR_ERR(cookie); 3284 return PTR_ERR(cookie);
3285 3285
3286 res = vfs_readlink(dentry, buffer, buflen, nd_get_link(&nd)); 3286 res = vfs_readlink(dentry, buffer, buflen, nd_get_link(&nd));
3287 if (dentry->d_inode->i_op->put_link) 3287 if (dentry->d_inode->i_op->put_link)
3288 dentry->d_inode->i_op->put_link(dentry, &nd, cookie); 3288 dentry->d_inode->i_op->put_link(dentry, &nd, cookie);
3289 return res; 3289 return res;
3290 } 3290 }
3291 3291
3292 int vfs_follow_link(struct nameidata *nd, const char *link) 3292 int vfs_follow_link(struct nameidata *nd, const char *link)
3293 { 3293 {
3294 return __vfs_follow_link(nd, link); 3294 return __vfs_follow_link(nd, link);
3295 } 3295 }
3296 3296
3297 /* get the link contents into pagecache */ 3297 /* get the link contents into pagecache */
3298 static char *page_getlink(struct dentry * dentry, struct page **ppage) 3298 static char *page_getlink(struct dentry * dentry, struct page **ppage)
3299 { 3299 {
3300 char *kaddr; 3300 char *kaddr;
3301 struct page *page; 3301 struct page *page;
3302 struct address_space *mapping = dentry->d_inode->i_mapping; 3302 struct address_space *mapping = dentry->d_inode->i_mapping;
3303 page = read_mapping_page(mapping, 0, NULL); 3303 page = read_mapping_page(mapping, 0, NULL);
3304 if (IS_ERR(page)) 3304 if (IS_ERR(page))
3305 return (char*)page; 3305 return (char*)page;
3306 *ppage = page; 3306 *ppage = page;
3307 kaddr = kmap(page); 3307 kaddr = kmap(page);
3308 nd_terminate_link(kaddr, dentry->d_inode->i_size, PAGE_SIZE - 1); 3308 nd_terminate_link(kaddr, dentry->d_inode->i_size, PAGE_SIZE - 1);
3309 return kaddr; 3309 return kaddr;
3310 } 3310 }
3311 3311
3312 int page_readlink(struct dentry *dentry, char __user *buffer, int buflen) 3312 int page_readlink(struct dentry *dentry, char __user *buffer, int buflen)
3313 { 3313 {
3314 struct page *page = NULL; 3314 struct page *page = NULL;
3315 char *s = page_getlink(dentry, &page); 3315 char *s = page_getlink(dentry, &page);
3316 int res = vfs_readlink(dentry,buffer,buflen,s); 3316 int res = vfs_readlink(dentry,buffer,buflen,s);
3317 if (page) { 3317 if (page) {
3318 kunmap(page); 3318 kunmap(page);
3319 page_cache_release(page); 3319 page_cache_release(page);
3320 } 3320 }
3321 return res; 3321 return res;
3322 } 3322 }
3323 3323
3324 void *page_follow_link_light(struct dentry *dentry, struct nameidata *nd) 3324 void *page_follow_link_light(struct dentry *dentry, struct nameidata *nd)
3325 { 3325 {
3326 struct page *page = NULL; 3326 struct page *page = NULL;
3327 nd_set_link(nd, page_getlink(dentry, &page)); 3327 nd_set_link(nd, page_getlink(dentry, &page));
3328 return page; 3328 return page;
3329 } 3329 }
3330 3330
3331 void page_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie) 3331 void page_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
3332 { 3332 {
3333 struct page *page = cookie; 3333 struct page *page = cookie;
3334 3334
3335 if (page) { 3335 if (page) {
3336 kunmap(page); 3336 kunmap(page);
3337 page_cache_release(page); 3337 page_cache_release(page);
3338 } 3338 }
3339 } 3339 }
3340 3340
3341 /* 3341 /*
3342 * The nofs argument instructs pagecache_write_begin to pass AOP_FLAG_NOFS 3342 * The nofs argument instructs pagecache_write_begin to pass AOP_FLAG_NOFS
3343 */ 3343 */
3344 int __page_symlink(struct inode *inode, const char *symname, int len, int nofs) 3344 int __page_symlink(struct inode *inode, const char *symname, int len, int nofs)
3345 { 3345 {
3346 struct address_space *mapping = inode->i_mapping; 3346 struct address_space *mapping = inode->i_mapping;
3347 struct page *page; 3347 struct page *page;
3348 void *fsdata; 3348 void *fsdata;
3349 int err; 3349 int err;
3350 char *kaddr; 3350 char *kaddr;
3351 unsigned int flags = AOP_FLAG_UNINTERRUPTIBLE; 3351 unsigned int flags = AOP_FLAG_UNINTERRUPTIBLE;
3352 if (nofs) 3352 if (nofs)
3353 flags |= AOP_FLAG_NOFS; 3353 flags |= AOP_FLAG_NOFS;
3354 3354
3355 retry: 3355 retry:
3356 err = pagecache_write_begin(NULL, mapping, 0, len-1, 3356 err = pagecache_write_begin(NULL, mapping, 0, len-1,
3357 flags, &page, &fsdata); 3357 flags, &page, &fsdata);
3358 if (err) 3358 if (err)
3359 goto fail; 3359 goto fail;
3360 3360
3361 kaddr = kmap_atomic(page, KM_USER0); 3361 kaddr = kmap_atomic(page, KM_USER0);
3362 memcpy(kaddr, symname, len-1); 3362 memcpy(kaddr, symname, len-1);
3363 kunmap_atomic(kaddr, KM_USER0); 3363 kunmap_atomic(kaddr, KM_USER0);
3364 3364
3365 err = pagecache_write_end(NULL, mapping, 0, len-1, len-1, 3365 err = pagecache_write_end(NULL, mapping, 0, len-1, len-1,
3366 page, fsdata); 3366 page, fsdata);
3367 if (err < 0) 3367 if (err < 0)
3368 goto fail; 3368 goto fail;
3369 if (err < len-1) 3369 if (err < len-1)
3370 goto retry; 3370 goto retry;
3371 3371
3372 mark_inode_dirty(inode); 3372 mark_inode_dirty(inode);
3373 return 0; 3373 return 0;
3374 fail: 3374 fail:
3375 return err; 3375 return err;
3376 } 3376 }
3377 3377
3378 int page_symlink(struct inode *inode, const char *symname, int len) 3378 int page_symlink(struct inode *inode, const char *symname, int len)
3379 { 3379 {
3380 return __page_symlink(inode, symname, len, 3380 return __page_symlink(inode, symname, len,
3381 !(mapping_gfp_mask(inode->i_mapping) & __GFP_FS)); 3381 !(mapping_gfp_mask(inode->i_mapping) & __GFP_FS));
3382 } 3382 }
3383 3383
3384 const struct inode_operations page_symlink_inode_operations = { 3384 const struct inode_operations page_symlink_inode_operations = {
3385 .readlink = generic_readlink, 3385 .readlink = generic_readlink,
3386 .follow_link = page_follow_link_light, 3386 .follow_link = page_follow_link_light,
3387 .put_link = page_put_link, 3387 .put_link = page_put_link,
3388 }; 3388 };
3389 3389
3390 EXPORT_SYMBOL(user_path_at); 3390 EXPORT_SYMBOL(user_path_at);
3391 EXPORT_SYMBOL(follow_down_one); 3391 EXPORT_SYMBOL(follow_down_one);
3392 EXPORT_SYMBOL(follow_down); 3392 EXPORT_SYMBOL(follow_down);
3393 EXPORT_SYMBOL(follow_up); 3393 EXPORT_SYMBOL(follow_up);
3394 EXPORT_SYMBOL(get_write_access); /* binfmt_aout */ 3394 EXPORT_SYMBOL(get_write_access); /* binfmt_aout */
3395 EXPORT_SYMBOL(getname); 3395 EXPORT_SYMBOL(getname);
3396 EXPORT_SYMBOL(lock_rename); 3396 EXPORT_SYMBOL(lock_rename);
3397 EXPORT_SYMBOL(lookup_one_len); 3397 EXPORT_SYMBOL(lookup_one_len);
3398 EXPORT_SYMBOL(page_follow_link_light); 3398 EXPORT_SYMBOL(page_follow_link_light);
3399 EXPORT_SYMBOL(page_put_link); 3399 EXPORT_SYMBOL(page_put_link);
3400 EXPORT_SYMBOL(page_readlink); 3400 EXPORT_SYMBOL(page_readlink);
3401 EXPORT_SYMBOL(__page_symlink); 3401 EXPORT_SYMBOL(__page_symlink);
3402 EXPORT_SYMBOL(page_symlink); 3402 EXPORT_SYMBOL(page_symlink);
3403 EXPORT_SYMBOL(page_symlink_inode_operations); 3403 EXPORT_SYMBOL(page_symlink_inode_operations);
3404 EXPORT_SYMBOL(kern_path_parent); 3404 EXPORT_SYMBOL(kern_path_parent);
3405 EXPORT_SYMBOL(kern_path); 3405 EXPORT_SYMBOL(kern_path);
3406 EXPORT_SYMBOL(vfs_path_lookup); 3406 EXPORT_SYMBOL(vfs_path_lookup);
3407 EXPORT_SYMBOL(inode_permission); 3407 EXPORT_SYMBOL(inode_permission);
3408 EXPORT_SYMBOL(file_permission); 3408 EXPORT_SYMBOL(file_permission);
3409 EXPORT_SYMBOL(unlock_rename); 3409 EXPORT_SYMBOL(unlock_rename);
3410 EXPORT_SYMBOL(vfs_create); 3410 EXPORT_SYMBOL(vfs_create);
3411 EXPORT_SYMBOL(vfs_follow_link); 3411 EXPORT_SYMBOL(vfs_follow_link);
3412 EXPORT_SYMBOL(vfs_link); 3412 EXPORT_SYMBOL(vfs_link);
3413 EXPORT_SYMBOL(vfs_mkdir); 3413 EXPORT_SYMBOL(vfs_mkdir);
3414 EXPORT_SYMBOL(vfs_mknod); 3414 EXPORT_SYMBOL(vfs_mknod);