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