Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/fs/namei.c

  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/export.h>
 19 #include <linux/kernel.h>
 20 #include <linux/slab.h>
 21 #include <linux/fs.h>
 22 #include <linux/namei.h>
 23 #include <linux/pagemap.h>
 24 #include <linux/fsnotify.h>
 25 #include <linux/personality.h>
 26 #include <linux/security.h>
 27 #include <linux/ima.h>
 28 #include <linux/syscalls.h>
 29 #include <linux/mount.h>
 30 #include <linux/audit.h>
 31 #include <linux/capability.h>
 32 #include <linux/file.h>
 33 #include <linux/fcntl.h>
 34 #include <linux/device_cgroup.h>
 35 #include <linux/fs_struct.h>
 36 #include <linux/posix_acl.h>
 37 #include <asm/uaccess.h>
 38 
 39 #include "internal.h"
 40 #include "mount.h"
 41 
 42 /* [Feb-1997 T. Schoebel-Theuer]
 43  * Fundamental changes in the pathname lookup mechanisms (namei)
 44  * were necessary because of omirr.  The reason is that omirr needs
 45  * to know the _real_ pathname, not the user-supplied one, in case
 46  * of symlinks (and also when transname replacements occur).
 47  *
 48  * The new code replaces the old recursive symlink resolution with
 49  * an iterative one (in case of non-nested symlink chains).  It does
 50  * this with calls to <fs>_follow_link().
 51  * As a side effect, dir_namei(), _namei() and follow_link() are now 
 52  * replaced with a single function lookup_dentry() that can handle all 
 53  * the special cases of the former code.
 54  *
 55  * With the new dcache, the pathname is stored at each inode, at least as
 56  * long as the refcount of the inode is positive.  As a side effect, the
 57  * size of the dcache depends on the inode cache and thus is dynamic.
 58  *
 59  * [29-Apr-1998 C. Scott Ananian] Updated above description of symlink
 60  * resolution to correspond with current state of the code.
 61  *
 62  * Note that the symlink resolution is not *completely* iterative.
 63  * There is still a significant amount of tail- and mid- recursion in
 64  * the algorithm.  Also, note that <fs>_readlink() is not used in
 65  * lookup_dentry(): lookup_dentry() on the result of <fs>_readlink()
 66  * may return different results than <fs>_follow_link().  Many virtual
 67  * filesystems (including /proc) exhibit this behavior.
 68  */
 69 
 70 /* [24-Feb-97 T. Schoebel-Theuer] Side effects caused by new implementation:
 71  * New symlink semantics: when open() is called with flags O_CREAT | O_EXCL
 72  * and the name already exists in form of a symlink, try to create the new
 73  * name indicated by the symlink. The old code always complained that the
 74  * name already exists, due to not following the symlink even if its target
 75  * is nonexistent.  The new semantics affects also mknod() and link() when
 76  * the name is a symlink pointing to a non-existent name.
 77  *
 78  * I don't know which semantics is the right one, since I have no access
 79  * to standards. But I found by trial that HP-UX 9.0 has the full "new"
 80  * semantics implemented, while SunOS 4.1.1 and Solaris (SunOS 5.4) have the
 81  * "old" one. Personally, I think the new semantics is much more logical.
 82  * Note that "ln old new" where "new" is a symlink pointing to a non-existing
 83  * file does succeed in both HP-UX and SunOs, but not in Solaris
 84  * and in the old Linux semantics.
 85  */
 86 
 87 /* [16-Dec-97 Kevin Buhr] For security reasons, we change some symlink
 88  * semantics.  See the comments in "open_namei" and "do_link" below.
 89  *
 90  * [10-Sep-98 Alan Modra] Another symlink change.
 91  */
 92 
 93 /* [Feb-Apr 2000 AV] Complete rewrite. Rules for symlinks:
 94  *      inside the path - always follow.
 95  *      in the last component in creation/removal/renaming - never follow.
 96  *      if LOOKUP_FOLLOW passed - follow.
 97  *      if the pathname has trailing slashes - follow.
 98  *      otherwise - don't follow.
 99  * (applied in that order).
100  *
101  * [Jun 2000 AV] Inconsistent behaviour of open() in case if flags==O_CREAT
102  * restored for 2.4. This is the last surviving part of old 4.2BSD bug.
103  * During the 2.4 we need to fix the userland stuff depending on it -
104  * hopefully we will be able to get rid of that wart in 2.5. So far only
105  * XEmacs seems to be relying on it...
106  */
107 /*
108  * [Sep 2001 AV] Single-semaphore locking scheme (kudos to David Holland)
109  * implemented.  Let's see if raised priority of ->s_vfs_rename_mutex gives
110  * any extra contention...
111  */
112 
113 /* In order to reduce some races, while at the same time doing additional
114  * checking and hopefully speeding things up, we copy filenames to the
115  * kernel data space before using them..
116  *
117  * POSIX.1 2.4: an empty pathname is invalid (ENOENT).
118  * PATH_MAX includes the nul terminator --RR.
119  */
120 void final_putname(struct filename *name)
121 {
122         if (name->separate) {
123                 __putname(name->name);
124                 kfree(name);
125         } else {
126                 __putname(name);
127         }
128 }
129 
130 #define EMBEDDED_NAME_MAX       (PATH_MAX - sizeof(struct filename))
131 
132 static struct filename *
133 getname_flags(const char __user *filename, int flags, int *empty)
134 {
135         struct filename *result, *err;
136         int len;
137         long max;
138         char *kname;
139 
140         result = audit_reusename(filename);
141         if (result)
142                 return result;
143 
144         result = __getname();
145         if (unlikely(!result))
146                 return ERR_PTR(-ENOMEM);
147 
148         /*
149          * First, try to embed the struct filename inside the names_cache
150          * allocation
151          */
152         kname = (char *)result + sizeof(*result);
153         result->name = kname;
154         result->separate = false;
155         max = EMBEDDED_NAME_MAX;
156 
157 recopy:
158         len = strncpy_from_user(kname, filename, max);
159         if (unlikely(len < 0)) {
160                 err = ERR_PTR(len);
161                 goto error;
162         }
163 
164         /*
165          * Uh-oh. We have a name that's approaching PATH_MAX. Allocate a
166          * separate struct filename so we can dedicate the entire
167          * names_cache allocation for the pathname, and re-do the copy from
168          * userland.
169          */
170         if (len == EMBEDDED_NAME_MAX && max == EMBEDDED_NAME_MAX) {
171                 kname = (char *)result;
172 
173                 result = kzalloc(sizeof(*result), GFP_KERNEL);
174                 if (!result) {
175                         err = ERR_PTR(-ENOMEM);
176                         result = (struct filename *)kname;
177                         goto error;
178                 }
179                 result->name = kname;
180                 result->separate = true;
181                 max = PATH_MAX;
182                 goto recopy;
183         }
184 
185         /* The empty path is special. */
186         if (unlikely(!len)) {
187                 if (empty)
188                         *empty = 1;
189                 err = ERR_PTR(-ENOENT);
190                 if (!(flags & LOOKUP_EMPTY))
191                         goto error;
192         }
193 
194         err = ERR_PTR(-ENAMETOOLONG);
195         if (unlikely(len >= PATH_MAX))
196                 goto error;
197 
198         result->uptr = filename;
199         result->aname = NULL;
200         audit_getname(result);
201         return result;
202 
203 error:
204         final_putname(result);
205         return err;
206 }
207 
208 struct filename *
209 getname(const char __user * filename)
210 {
211         return getname_flags(filename, 0, NULL);
212 }
213 
214 /*
215  * The "getname_kernel()" interface doesn't do pathnames longer
216  * than EMBEDDED_NAME_MAX. Deal with it - you're a kernel user.
217  */
218 struct filename *
219 getname_kernel(const char * filename)
220 {
221         struct filename *result;
222         char *kname;
223         int len;
224 
225         len = strlen(filename);
226         if (len >= EMBEDDED_NAME_MAX)
227                 return ERR_PTR(-ENAMETOOLONG);
228 
229         result = __getname();
230         if (unlikely(!result))
231                 return ERR_PTR(-ENOMEM);
232 
233         kname = (char *)result + sizeof(*result);
234         result->name = kname;
235         result->uptr = NULL;
236         result->aname = NULL;
237         result->separate = false;
238 
239         strlcpy(kname, filename, EMBEDDED_NAME_MAX);
240         return result;
241 }
242 
243 #ifdef CONFIG_AUDITSYSCALL
244 void putname(struct filename *name)
245 {
246         if (unlikely(!audit_dummy_context()))
247                 return audit_putname(name);
248         final_putname(name);
249 }
250 #endif
251 
252 static int check_acl(struct inode *inode, int mask)
253 {
254 #ifdef CONFIG_FS_POSIX_ACL
255         struct posix_acl *acl;
256 
257         if (mask & MAY_NOT_BLOCK) {
258                 acl = get_cached_acl_rcu(inode, ACL_TYPE_ACCESS);
259                 if (!acl)
260                         return -EAGAIN;
261                 /* no ->get_acl() calls in RCU mode... */
262                 if (acl == ACL_NOT_CACHED)
263                         return -ECHILD;
264                 return posix_acl_permission(inode, acl, mask & ~MAY_NOT_BLOCK);
265         }
266 
267         acl = get_acl(inode, ACL_TYPE_ACCESS);
268         if (IS_ERR(acl))
269                 return PTR_ERR(acl);
270         if (acl) {
271                 int error = posix_acl_permission(inode, acl, mask);
272                 posix_acl_release(acl);
273                 return error;
274         }
275 #endif
276 
277         return -EAGAIN;
278 }
279 
280 /*
281  * This does the basic permission checking
282  */
283 static int acl_permission_check(struct inode *inode, int mask)
284 {
285         unsigned int mode = inode->i_mode;
286 
287         if (likely(uid_eq(current_fsuid(), inode->i_uid)))
288                 mode >>= 6;
289         else {
290                 if (IS_POSIXACL(inode) && (mode & S_IRWXG)) {
291                         int error = check_acl(inode, mask);
292                         if (error != -EAGAIN)
293                                 return error;
294                 }
295 
296                 if (in_group_p(inode->i_gid))
297                         mode >>= 3;
298         }
299 
300         /*
301          * If the DACs are ok we don't need any capability check.
302          */
303         if ((mask & ~mode & (MAY_READ | MAY_WRITE | MAY_EXEC)) == 0)
304                 return 0;
305         return -EACCES;
306 }
307 
308 /**
309  * generic_permission -  check for access rights on a Posix-like filesystem
310  * @inode:      inode to check access rights for
311  * @mask:       right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC, ...)
312  *
313  * Used to check for read/write/execute permissions on a file.
314  * We use "fsuid" for this, letting us set arbitrary permissions
315  * for filesystem access without changing the "normal" uids which
316  * are used for other things.
317  *
318  * generic_permission is rcu-walk aware. It returns -ECHILD in case an rcu-walk
319  * request cannot be satisfied (eg. requires blocking or too much complexity).
320  * It would then be called again in ref-walk mode.
321  */
322 int generic_permission(struct inode *inode, int mask)
323 {
324         int ret;
325 
326         /*
327          * Do the basic permission checks.
328          */
329         ret = acl_permission_check(inode, mask);
330         if (ret != -EACCES)
331                 return ret;
332 
333         if (S_ISDIR(inode->i_mode)) {
334                 /* DACs are overridable for directories */
335                 if (inode_capable(inode, CAP_DAC_OVERRIDE))
336                         return 0;
337                 if (!(mask & MAY_WRITE))
338                         if (inode_capable(inode, CAP_DAC_READ_SEARCH))
339                                 return 0;
340                 return -EACCES;
341         }
342         /*
343          * Read/write DACs are always overridable.
344          * Executable DACs are overridable when there is
345          * at least one exec bit set.
346          */
347         if (!(mask & MAY_EXEC) || (inode->i_mode & S_IXUGO))
348                 if (inode_capable(inode, CAP_DAC_OVERRIDE))
349                         return 0;
350 
351         /*
352          * Searching includes executable on directories, else just read.
353          */
354         mask &= MAY_READ | MAY_WRITE | MAY_EXEC;
355         if (mask == MAY_READ)
356                 if (inode_capable(inode, CAP_DAC_READ_SEARCH))
357                         return 0;
358 
359         return -EACCES;
360 }
361 EXPORT_SYMBOL(generic_permission);
362 
363 /*
364  * We _really_ want to just do "generic_permission()" without
365  * even looking at the inode->i_op values. So we keep a cache
366  * flag in inode->i_opflags, that says "this has not special
367  * permission function, use the fast case".
368  */
369 static inline int do_inode_permission(struct inode *inode, int mask)
370 {
371         if (unlikely(!(inode->i_opflags & IOP_FASTPERM))) {
372                 if (likely(inode->i_op->permission))
373                         return inode->i_op->permission(inode, mask);
374 
375                 /* This gets set once for the inode lifetime */
376                 spin_lock(&inode->i_lock);
377                 inode->i_opflags |= IOP_FASTPERM;
378                 spin_unlock(&inode->i_lock);
379         }
380         return generic_permission(inode, mask);
381 }
382 
383 /**
384  * __inode_permission - Check for access rights to a given inode
385  * @inode: Inode to check permission on
386  * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
387  *
388  * Check for read/write/execute permissions on an inode.
389  *
390  * When checking for MAY_APPEND, MAY_WRITE must also be set in @mask.
391  *
392  * This does not check for a read-only file system.  You probably want
393  * inode_permission().
394  */
395 int __inode_permission(struct inode *inode, int mask)
396 {
397         int retval;
398 
399         if (unlikely(mask & MAY_WRITE)) {
400                 /*
401                  * Nobody gets write access to an immutable file.
402                  */
403                 if (IS_IMMUTABLE(inode))
404                         return -EACCES;
405         }
406 
407         retval = do_inode_permission(inode, mask);
408         if (retval)
409                 return retval;
410 
411         retval = devcgroup_inode_permission(inode, mask);
412         if (retval)
413                 return retval;
414 
415         return security_inode_permission(inode, mask);
416 }
417 
418 /**
419  * sb_permission - Check superblock-level permissions
420  * @sb: Superblock of inode to check permission on
421  * @inode: Inode to check permission on
422  * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
423  *
424  * Separate out file-system wide checks from inode-specific permission checks.
425  */
426 static int sb_permission(struct super_block *sb, struct inode *inode, int mask)
427 {
428         if (unlikely(mask & MAY_WRITE)) {
429                 umode_t mode = inode->i_mode;
430 
431                 /* Nobody gets write access to a read-only fs. */
432                 if ((sb->s_flags & MS_RDONLY) &&
433                     (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
434                         return -EROFS;
435         }
436         return 0;
437 }
438 
439 /**
440  * inode_permission - Check for access rights to a given inode
441  * @inode: Inode to check permission on
442  * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
443  *
444  * Check for read/write/execute permissions on an inode.  We use fs[ug]id for
445  * this, letting us set arbitrary permissions for filesystem access without
446  * changing the "normal" UIDs which are used for other things.
447  *
448  * When checking for MAY_APPEND, MAY_WRITE must also be set in @mask.
449  */
450 int inode_permission(struct inode *inode, int mask)
451 {
452         int retval;
453 
454         retval = sb_permission(inode->i_sb, inode, mask);
455         if (retval)
456                 return retval;
457         return __inode_permission(inode, mask);
458 }
459 EXPORT_SYMBOL(inode_permission);
460 
461 /**
462  * path_get - get a reference to a path
463  * @path: path to get the reference to
464  *
465  * Given a path increment the reference count to the dentry and the vfsmount.
466  */
467 void path_get(const struct path *path)
468 {
469         mntget(path->mnt);
470         dget(path->dentry);
471 }
472 EXPORT_SYMBOL(path_get);
473 
474 /**
475  * path_put - put a reference to a path
476  * @path: path to put the reference to
477  *
478  * Given a path decrement the reference count to the dentry and the vfsmount.
479  */
480 void path_put(const struct path *path)
481 {
482         dput(path->dentry);
483         mntput(path->mnt);
484 }
485 EXPORT_SYMBOL(path_put);
486 
487 /*
488  * Path walking has 2 modes, rcu-walk and ref-walk (see
489  * Documentation/filesystems/path-lookup.txt).  In situations when we can't
490  * continue in RCU mode, we attempt to drop out of rcu-walk mode and grab
491  * normal reference counts on dentries and vfsmounts to transition to rcu-walk
492  * mode.  Refcounts are grabbed at the last known good point before rcu-walk
493  * got stuck, so ref-walk may continue from there. If this is not successful
494  * (eg. a seqcount has changed), then failure is returned and it's up to caller
495  * to restart the path walk from the beginning in ref-walk mode.
496  */
497 
498 /**
499  * unlazy_walk - try to switch to ref-walk mode.
500  * @nd: nameidata pathwalk data
501  * @dentry: child of nd->path.dentry or NULL
502  * Returns: 0 on success, -ECHILD on failure
503  *
504  * unlazy_walk attempts to legitimize the current nd->path, nd->root and dentry
505  * for ref-walk mode.  @dentry must be a path found by a do_lookup call on
506  * @nd or NULL.  Must be called from rcu-walk context.
507  */
508 static int unlazy_walk(struct nameidata *nd, struct dentry *dentry)
509 {
510         struct fs_struct *fs = current->fs;
511         struct dentry *parent = nd->path.dentry;
512 
513         BUG_ON(!(nd->flags & LOOKUP_RCU));
514 
515         /*
516          * After legitimizing the bastards, terminate_walk()
517          * will do the right thing for non-RCU mode, and all our
518          * subsequent exit cases should rcu_read_unlock()
519          * before returning.  Do vfsmount first; if dentry
520          * can't be legitimized, just set nd->path.dentry to NULL
521          * and rely on dput(NULL) being a no-op.
522          */
523         if (!legitimize_mnt(nd->path.mnt, nd->m_seq))
524                 return -ECHILD;
525         nd->flags &= ~LOOKUP_RCU;
526 
527         if (!lockref_get_not_dead(&parent->d_lockref)) {
528                 nd->path.dentry = NULL; 
529                 goto out;
530         }
531 
532         /*
533          * For a negative lookup, the lookup sequence point is the parents
534          * sequence point, and it only needs to revalidate the parent dentry.
535          *
536          * For a positive lookup, we need to move both the parent and the
537          * dentry from the RCU domain to be properly refcounted. And the
538          * sequence number in the dentry validates *both* dentry counters,
539          * since we checked the sequence number of the parent after we got
540          * the child sequence number. So we know the parent must still
541          * be valid if the child sequence number is still valid.
542          */
543         if (!dentry) {
544                 if (read_seqcount_retry(&parent->d_seq, nd->seq))
545                         goto out;
546                 BUG_ON(nd->inode != parent->d_inode);
547         } else {
548                 if (!lockref_get_not_dead(&dentry->d_lockref))
549                         goto out;
550                 if (read_seqcount_retry(&dentry->d_seq, nd->seq))
551                         goto drop_dentry;
552         }
553 
554         /*
555          * Sequence counts matched. Now make sure that the root is
556          * still valid and get it if required.
557          */
558         if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT)) {
559                 spin_lock(&fs->lock);
560                 if (nd->root.mnt != fs->root.mnt || nd->root.dentry != fs->root.dentry)
561                         goto unlock_and_drop_dentry;
562                 path_get(&nd->root);
563                 spin_unlock(&fs->lock);
564         }
565 
566         rcu_read_unlock();
567         return 0;
568 
569 unlock_and_drop_dentry:
570         spin_unlock(&fs->lock);
571 drop_dentry:
572         rcu_read_unlock();
573         dput(dentry);
574         goto drop_root_mnt;
575 out:
576         rcu_read_unlock();
577 drop_root_mnt:
578         if (!(nd->flags & LOOKUP_ROOT))
579                 nd->root.mnt = NULL;
580         return -ECHILD;
581 }
582 
583 static inline int d_revalidate(struct dentry *dentry, unsigned int flags)
584 {
585         return dentry->d_op->d_revalidate(dentry, flags);
586 }
587 
588 /**
589  * complete_walk - successful completion of path walk
590  * @nd:  pointer nameidata
591  *
592  * If we had been in RCU mode, drop out of it and legitimize nd->path.
593  * Revalidate the final result, unless we'd already done that during
594  * the path walk or the filesystem doesn't ask for it.  Return 0 on
595  * success, -error on failure.  In case of failure caller does not
596  * need to drop nd->path.
597  */
598 static int complete_walk(struct nameidata *nd)
599 {
600         struct dentry *dentry = nd->path.dentry;
601         int status;
602 
603         if (nd->flags & LOOKUP_RCU) {
604                 nd->flags &= ~LOOKUP_RCU;
605                 if (!(nd->flags & LOOKUP_ROOT))
606                         nd->root.mnt = NULL;
607 
608                 if (!legitimize_mnt(nd->path.mnt, nd->m_seq)) {
609                         rcu_read_unlock();
610                         return -ECHILD;
611                 }
612                 if (unlikely(!lockref_get_not_dead(&dentry->d_lockref))) {
613                         rcu_read_unlock();
614                         mntput(nd->path.mnt);
615                         return -ECHILD;
616                 }
617                 if (read_seqcount_retry(&dentry->d_seq, nd->seq)) {
618                         rcu_read_unlock();
619                         dput(dentry);
620                         mntput(nd->path.mnt);
621                         return -ECHILD;
622                 }
623                 rcu_read_unlock();
624         }
625 
626         if (likely(!(nd->flags & LOOKUP_JUMPED)))
627                 return 0;
628 
629         if (likely(!(dentry->d_flags & DCACHE_OP_WEAK_REVALIDATE)))
630                 return 0;
631 
632         status = dentry->d_op->d_weak_revalidate(dentry, nd->flags);
633         if (status > 0)
634                 return 0;
635 
636         if (!status)
637                 status = -ESTALE;
638 
639         path_put(&nd->path);
640         return status;
641 }
642 
643 static __always_inline void set_root(struct nameidata *nd)
644 {
645         if (!nd->root.mnt)
646                 get_fs_root(current->fs, &nd->root);
647 }
648 
649 static int link_path_walk(const char *, struct nameidata *);
650 
651 static __always_inline void set_root_rcu(struct nameidata *nd)
652 {
653         if (!nd->root.mnt) {
654                 struct fs_struct *fs = current->fs;
655                 unsigned seq;
656 
657                 do {
658                         seq = read_seqcount_begin(&fs->seq);
659                         nd->root = fs->root;
660                         nd->seq = __read_seqcount_begin(&nd->root.dentry->d_seq);
661                 } while (read_seqcount_retry(&fs->seq, seq));
662         }
663 }
664 
665 static void path_put_conditional(struct path *path, struct nameidata *nd)
666 {
667         dput(path->dentry);
668         if (path->mnt != nd->path.mnt)
669                 mntput(path->mnt);
670 }
671 
672 static inline void path_to_nameidata(const struct path *path,
673                                         struct nameidata *nd)
674 {
675         if (!(nd->flags & LOOKUP_RCU)) {
676                 dput(nd->path.dentry);
677                 if (nd->path.mnt != path->mnt)
678                         mntput(nd->path.mnt);
679         }
680         nd->path.mnt = path->mnt;
681         nd->path.dentry = path->dentry;
682 }
683 
684 /*
685  * Helper to directly jump to a known parsed path from ->follow_link,
686  * caller must have taken a reference to path beforehand.
687  */
688 void nd_jump_link(struct nameidata *nd, struct path *path)
689 {
690         path_put(&nd->path);
691 
692         nd->path = *path;
693         nd->inode = nd->path.dentry->d_inode;
694         nd->flags |= LOOKUP_JUMPED;
695 }
696 
697 static inline void put_link(struct nameidata *nd, struct path *link, void *cookie)
698 {
699         struct inode *inode = link->dentry->d_inode;
700         if (inode->i_op->put_link)
701                 inode->i_op->put_link(link->dentry, nd, cookie);
702         path_put(link);
703 }
704 
705 int sysctl_protected_symlinks __read_mostly = 0;
706 int sysctl_protected_hardlinks __read_mostly = 0;
707 
708 /**
709  * may_follow_link - Check symlink following for unsafe situations
710  * @link: The path of the symlink
711  * @nd: nameidata pathwalk data
712  *
713  * In the case of the sysctl_protected_symlinks sysctl being enabled,
714  * CAP_DAC_OVERRIDE needs to be specifically ignored if the symlink is
715  * in a sticky world-writable directory. This is to protect privileged
716  * processes from failing races against path names that may change out
717  * from under them by way of other users creating malicious symlinks.
718  * It will permit symlinks to be followed only when outside a sticky
719  * world-writable directory, or when the uid of the symlink and follower
720  * match, or when the directory owner matches the symlink's owner.
721  *
722  * Returns 0 if following the symlink is allowed, -ve on error.
723  */
724 static inline int may_follow_link(struct path *link, struct nameidata *nd)
725 {
726         const struct inode *inode;
727         const struct inode *parent;
728 
729         if (!sysctl_protected_symlinks)
730                 return 0;
731 
732         /* Allowed if owner and follower match. */
733         inode = link->dentry->d_inode;
734         if (uid_eq(current_cred()->fsuid, inode->i_uid))
735                 return 0;
736 
737         /* Allowed if parent directory not sticky and world-writable. */
738         parent = nd->path.dentry->d_inode;
739         if ((parent->i_mode & (S_ISVTX|S_IWOTH)) != (S_ISVTX|S_IWOTH))
740                 return 0;
741 
742         /* Allowed if parent directory and link owner match. */
743         if (uid_eq(parent->i_uid, inode->i_uid))
744                 return 0;
745 
746         audit_log_link_denied("follow_link", link);
747         path_put_conditional(link, nd);
748         path_put(&nd->path);
749         return -EACCES;
750 }
751 
752 /**
753  * safe_hardlink_source - Check for safe hardlink conditions
754  * @inode: the source inode to hardlink from
755  *
756  * Return false if at least one of the following conditions:
757  *    - inode is not a regular file
758  *    - inode is setuid
759  *    - inode is setgid and group-exec
760  *    - access failure for read and write
761  *
762  * Otherwise returns true.
763  */
764 static bool safe_hardlink_source(struct inode *inode)
765 {
766         umode_t mode = inode->i_mode;
767 
768         /* Special files should not get pinned to the filesystem. */
769         if (!S_ISREG(mode))
770                 return false;
771 
772         /* Setuid files should not get pinned to the filesystem. */
773         if (mode & S_ISUID)
774                 return false;
775 
776         /* Executable setgid files should not get pinned to the filesystem. */
777         if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP))
778                 return false;
779 
780         /* Hardlinking to unreadable or unwritable sources is dangerous. */
781         if (inode_permission(inode, MAY_READ | MAY_WRITE))
782                 return false;
783 
784         return true;
785 }
786 
787 /**
788  * may_linkat - Check permissions for creating a hardlink
789  * @link: the source to hardlink from
790  *
791  * Block hardlink when all of:
792  *  - sysctl_protected_hardlinks enabled
793  *  - fsuid does not match inode
794  *  - hardlink source is unsafe (see safe_hardlink_source() above)
795  *  - not CAP_FOWNER
796  *
797  * Returns 0 if successful, -ve on error.
798  */
799 static int may_linkat(struct path *link)
800 {
801         const struct cred *cred;
802         struct inode *inode;
803 
804         if (!sysctl_protected_hardlinks)
805                 return 0;
806 
807         cred = current_cred();
808         inode = link->dentry->d_inode;
809 
810         /* Source inode owner (or CAP_FOWNER) can hardlink all they like,
811          * otherwise, it must be a safe source.
812          */
813         if (uid_eq(cred->fsuid, inode->i_uid) || safe_hardlink_source(inode) ||
814             capable(CAP_FOWNER))
815                 return 0;
816 
817         audit_log_link_denied("linkat", link);
818         return -EPERM;
819 }
820 
821 static __always_inline int
822 follow_link(struct path *link, struct nameidata *nd, void **p)
823 {
824         struct dentry *dentry = link->dentry;
825         int error;
826         char *s;
827 
828         BUG_ON(nd->flags & LOOKUP_RCU);
829 
830         if (link->mnt == nd->path.mnt)
831                 mntget(link->mnt);
832 
833         error = -ELOOP;
834         if (unlikely(current->total_link_count >= 40))
835                 goto out_put_nd_path;
836 
837         cond_resched();
838         current->total_link_count++;
839 
840         touch_atime(link);
841         nd_set_link(nd, NULL);
842 
843         error = security_inode_follow_link(link->dentry, nd);
844         if (error)
845                 goto out_put_nd_path;
846 
847         nd->last_type = LAST_BIND;
848         *p = dentry->d_inode->i_op->follow_link(dentry, nd);
849         error = PTR_ERR(*p);
850         if (IS_ERR(*p))
851                 goto out_put_nd_path;
852 
853         error = 0;
854         s = nd_get_link(nd);
855         if (s) {
856                 if (unlikely(IS_ERR(s))) {
857                         path_put(&nd->path);
858                         put_link(nd, link, *p);
859                         return PTR_ERR(s);
860                 }
861                 if (*s == '/') {
862                         set_root(nd);
863                         path_put(&nd->path);
864                         nd->path = nd->root;
865                         path_get(&nd->root);
866                         nd->flags |= LOOKUP_JUMPED;
867                 }
868                 nd->inode = nd->path.dentry->d_inode;
869                 error = link_path_walk(s, nd);
870                 if (unlikely(error))
871                         put_link(nd, link, *p);
872         }
873 
874         return error;
875 
876 out_put_nd_path:
877         *p = NULL;
878         path_put(&nd->path);
879         path_put(link);
880         return error;
881 }
882 
883 static int follow_up_rcu(struct path *path)
884 {
885         struct mount *mnt = real_mount(path->mnt);
886         struct mount *parent;
887         struct dentry *mountpoint;
888 
889         parent = mnt->mnt_parent;
890         if (&parent->mnt == path->mnt)
891                 return 0;
892         mountpoint = mnt->mnt_mountpoint;
893         path->dentry = mountpoint;
894         path->mnt = &parent->mnt;
895         return 1;
896 }
897 
898 /*
899  * follow_up - Find the mountpoint of path's vfsmount
900  *
901  * Given a path, find the mountpoint of its source file system.
902  * Replace @path with the path of the mountpoint in the parent mount.
903  * Up is towards /.
904  *
905  * Return 1 if we went up a level and 0 if we were already at the
906  * root.
907  */
908 int follow_up(struct path *path)
909 {
910         struct mount *mnt = real_mount(path->mnt);
911         struct mount *parent;
912         struct dentry *mountpoint;
913 
914         read_seqlock_excl(&mount_lock);
915         parent = mnt->mnt_parent;
916         if (parent == mnt) {
917                 read_sequnlock_excl(&mount_lock);
918                 return 0;
919         }
920         mntget(&parent->mnt);
921         mountpoint = dget(mnt->mnt_mountpoint);
922         read_sequnlock_excl(&mount_lock);
923         dput(path->dentry);
924         path->dentry = mountpoint;
925         mntput(path->mnt);
926         path->mnt = &parent->mnt;
927         return 1;
928 }
929 EXPORT_SYMBOL(follow_up);
930 
931 /*
932  * Perform an automount
933  * - return -EISDIR to tell follow_managed() to stop and return the path we
934  *   were called with.
935  */
936 static int follow_automount(struct path *path, unsigned flags,
937                             bool *need_mntput)
938 {
939         struct vfsmount *mnt;
940         int err;
941 
942         if (!path->dentry->d_op || !path->dentry->d_op->d_automount)
943                 return -EREMOTE;
944 
945         /* We don't want to mount if someone's just doing a stat -
946          * unless they're stat'ing a directory and appended a '/' to
947          * the name.
948          *
949          * We do, however, want to mount if someone wants to open or
950          * create a file of any type under the mountpoint, wants to
951          * traverse through the mountpoint or wants to open the
952          * mounted directory.  Also, autofs may mark negative dentries
953          * as being automount points.  These will need the attentions
954          * of the daemon to instantiate them before they can be used.
955          */
956         if (!(flags & (LOOKUP_PARENT | LOOKUP_DIRECTORY |
957                      LOOKUP_OPEN | LOOKUP_CREATE | LOOKUP_AUTOMOUNT)) &&
958             path->dentry->d_inode)
959                 return -EISDIR;
960 
961         current->total_link_count++;
962         if (current->total_link_count >= 40)
963                 return -ELOOP;
964 
965         mnt = path->dentry->d_op->d_automount(path);
966         if (IS_ERR(mnt)) {
967                 /*
968                  * The filesystem is allowed to return -EISDIR here to indicate
969                  * it doesn't want to automount.  For instance, autofs would do
970                  * this so that its userspace daemon can mount on this dentry.
971                  *
972                  * However, we can only permit this if it's a terminal point in
973                  * the path being looked up; if it wasn't then the remainder of
974                  * the path is inaccessible and we should say so.
975                  */
976                 if (PTR_ERR(mnt) == -EISDIR && (flags & LOOKUP_PARENT))
977                         return -EREMOTE;
978                 return PTR_ERR(mnt);
979         }
980 
981         if (!mnt) /* mount collision */
982                 return 0;
983 
984         if (!*need_mntput) {
985                 /* lock_mount() may release path->mnt on error */
986                 mntget(path->mnt);
987                 *need_mntput = true;
988         }
989         err = finish_automount(mnt, path);
990 
991         switch (err) {
992         case -EBUSY:
993                 /* Someone else made a mount here whilst we were busy */
994                 return 0;
995         case 0:
996                 path_put(path);
997                 path->mnt = mnt;
998                 path->dentry = dget(mnt->mnt_root);
999                 return 0;
1000         default:
1001                 return err;
1002         }
1003 
1004 }
1005 
1006 /*
1007  * Handle a dentry that is managed in some way.
1008  * - Flagged for transit management (autofs)
1009  * - Flagged as mountpoint
1010  * - Flagged as automount point
1011  *
1012  * This may only be called in refwalk mode.
1013  *
1014  * Serialization is taken care of in namespace.c
1015  */
1016 static int follow_managed(struct path *path, unsigned flags)
1017 {
1018         struct vfsmount *mnt = path->mnt; /* held by caller, must be left alone */
1019         unsigned managed;
1020         bool need_mntput = false;
1021         int ret = 0;
1022 
1023         /* Given that we're not holding a lock here, we retain the value in a
1024          * local variable for each dentry as we look at it so that we don't see
1025          * the components of that value change under us */
1026         while (managed = ACCESS_ONCE(path->dentry->d_flags),
1027                managed &= DCACHE_MANAGED_DENTRY,
1028                unlikely(managed != 0)) {
1029                 /* Allow the filesystem to manage the transit without i_mutex
1030                  * being held. */
1031                 if (managed & DCACHE_MANAGE_TRANSIT) {
1032                         BUG_ON(!path->dentry->d_op);
1033                         BUG_ON(!path->dentry->d_op->d_manage);
1034                         ret = path->dentry->d_op->d_manage(path->dentry, false);
1035                         if (ret < 0)
1036                                 break;
1037                 }
1038 
1039                 /* Transit to a mounted filesystem. */
1040                 if (managed & DCACHE_MOUNTED) {
1041                         struct vfsmount *mounted = lookup_mnt(path);
1042                         if (mounted) {
1043                                 dput(path->dentry);
1044                                 if (need_mntput)
1045                                         mntput(path->mnt);
1046                                 path->mnt = mounted;
1047                                 path->dentry = dget(mounted->mnt_root);
1048                                 need_mntput = true;
1049                                 continue;
1050                         }
1051 
1052                         /* Something is mounted on this dentry in another
1053                          * namespace and/or whatever was mounted there in this
1054                          * namespace got unmounted before lookup_mnt() could
1055                          * get it */
1056                 }
1057 
1058                 /* Handle an automount point */
1059                 if (managed & DCACHE_NEED_AUTOMOUNT) {
1060                         ret = follow_automount(path, flags, &need_mntput);
1061                         if (ret < 0)
1062                                 break;
1063                         continue;
1064                 }
1065 
1066                 /* We didn't change the current path point */
1067                 break;
1068         }
1069 
1070         if (need_mntput && path->mnt == mnt)
1071                 mntput(path->mnt);
1072         if (ret == -EISDIR)
1073                 ret = 0;
1074         return ret < 0 ? ret : need_mntput;
1075 }
1076 
1077 int follow_down_one(struct path *path)
1078 {
1079         struct vfsmount *mounted;
1080 
1081         mounted = lookup_mnt(path);
1082         if (mounted) {
1083                 dput(path->dentry);
1084                 mntput(path->mnt);
1085                 path->mnt = mounted;
1086                 path->dentry = dget(mounted->mnt_root);
1087                 return 1;
1088         }
1089         return 0;
1090 }
1091 EXPORT_SYMBOL(follow_down_one);
1092 
1093 static inline bool managed_dentry_might_block(struct dentry *dentry)
1094 {
1095         return (dentry->d_flags & DCACHE_MANAGE_TRANSIT &&
1096                 dentry->d_op->d_manage(dentry, true) < 0);
1097 }
1098 
1099 /*
1100  * Try to skip to top of mountpoint pile in rcuwalk mode.  Fail if
1101  * we meet a managed dentry that would need blocking.
1102  */
1103 static bool __follow_mount_rcu(struct nameidata *nd, struct path *path,
1104                                struct inode **inode)
1105 {
1106         for (;;) {
1107                 struct mount *mounted;
1108                 /*
1109                  * Don't forget we might have a non-mountpoint managed dentry
1110                  * that wants to block transit.
1111                  */
1112                 if (unlikely(managed_dentry_might_block(path->dentry)))
1113                         return false;
1114 
1115                 if (!d_mountpoint(path->dentry))
1116                         return true;
1117 
1118                 mounted = __lookup_mnt(path->mnt, path->dentry);
1119                 if (!mounted)
1120                         break;
1121                 path->mnt = &mounted->mnt;
1122                 path->dentry = mounted->mnt.mnt_root;
1123                 nd->flags |= LOOKUP_JUMPED;
1124                 nd->seq = read_seqcount_begin(&path->dentry->d_seq);
1125                 /*
1126                  * Update the inode too. We don't need to re-check the
1127                  * dentry sequence number here after this d_inode read,
1128                  * because a mount-point is always pinned.
1129                  */
1130                 *inode = path->dentry->d_inode;
1131         }
1132         return read_seqretry(&mount_lock, nd->m_seq);
1133 }
1134 
1135 static int follow_dotdot_rcu(struct nameidata *nd)
1136 {
1137         set_root_rcu(nd);
1138 
1139         while (1) {
1140                 if (nd->path.dentry == nd->root.dentry &&
1141                     nd->path.mnt == nd->root.mnt) {
1142                         break;
1143                 }
1144                 if (nd->path.dentry != nd->path.mnt->mnt_root) {
1145                         struct dentry *old = nd->path.dentry;
1146                         struct dentry *parent = old->d_parent;
1147                         unsigned seq;
1148 
1149                         seq = read_seqcount_begin(&parent->d_seq);
1150                         if (read_seqcount_retry(&old->d_seq, nd->seq))
1151                                 goto failed;
1152                         nd->path.dentry = parent;
1153                         nd->seq = seq;
1154                         break;
1155                 }
1156                 if (!follow_up_rcu(&nd->path))
1157                         break;
1158                 nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
1159         }
1160         while (d_mountpoint(nd->path.dentry)) {
1161                 struct mount *mounted;
1162                 mounted = __lookup_mnt(nd->path.mnt, nd->path.dentry);
1163                 if (!mounted)
1164                         break;
1165                 nd->path.mnt = &mounted->mnt;
1166                 nd->path.dentry = mounted->mnt.mnt_root;
1167                 nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
1168                 if (!read_seqretry(&mount_lock, nd->m_seq))
1169                         goto failed;
1170         }
1171         nd->inode = nd->path.dentry->d_inode;
1172         return 0;
1173 
1174 failed:
1175         nd->flags &= ~LOOKUP_RCU;
1176         if (!(nd->flags & LOOKUP_ROOT))
1177                 nd->root.mnt = NULL;
1178         rcu_read_unlock();
1179         return -ECHILD;
1180 }
1181 
1182 /*
1183  * Follow down to the covering mount currently visible to userspace.  At each
1184  * point, the filesystem owning that dentry may be queried as to whether the
1185  * caller is permitted to proceed or not.
1186  */
1187 int follow_down(struct path *path)
1188 {
1189         unsigned managed;
1190         int ret;
1191 
1192         while (managed = ACCESS_ONCE(path->dentry->d_flags),
1193                unlikely(managed & DCACHE_MANAGED_DENTRY)) {
1194                 /* Allow the filesystem to manage the transit without i_mutex
1195                  * being held.
1196                  *
1197                  * We indicate to the filesystem if someone is trying to mount
1198                  * something here.  This gives autofs the chance to deny anyone
1199                  * other than its daemon the right to mount on its
1200                  * superstructure.
1201                  *
1202                  * The filesystem may sleep at this point.
1203                  */
1204                 if (managed & DCACHE_MANAGE_TRANSIT) {
1205                         BUG_ON(!path->dentry->d_op);
1206                         BUG_ON(!path->dentry->d_op->d_manage);
1207                         ret = path->dentry->d_op->d_manage(
1208                                 path->dentry, false);
1209                         if (ret < 0)
1210                                 return ret == -EISDIR ? 0 : ret;
1211                 }
1212 
1213                 /* Transit to a mounted filesystem. */
1214                 if (managed & DCACHE_MOUNTED) {
1215                         struct vfsmount *mounted = lookup_mnt(path);
1216                         if (!mounted)
1217                                 break;
1218                         dput(path->dentry);
1219                         mntput(path->mnt);
1220                         path->mnt = mounted;
1221                         path->dentry = dget(mounted->mnt_root);
1222                         continue;
1223                 }
1224 
1225                 /* Don't handle automount points here */
1226                 break;
1227         }
1228         return 0;
1229 }
1230 EXPORT_SYMBOL(follow_down);
1231 
1232 /*
1233  * Skip to top of mountpoint pile in refwalk mode for follow_dotdot()
1234  */
1235 static void follow_mount(struct path *path)
1236 {
1237         while (d_mountpoint(path->dentry)) {
1238                 struct vfsmount *mounted = lookup_mnt(path);
1239                 if (!mounted)
1240                         break;
1241                 dput(path->dentry);
1242                 mntput(path->mnt);
1243                 path->mnt = mounted;
1244                 path->dentry = dget(mounted->mnt_root);
1245         }
1246 }
1247 
1248 static void follow_dotdot(struct nameidata *nd)
1249 {
1250         set_root(nd);
1251 
1252         while(1) {
1253                 struct dentry *old = nd->path.dentry;
1254 
1255                 if (nd->path.dentry == nd->root.dentry &&
1256                     nd->path.mnt == nd->root.mnt) {
1257                         break;
1258                 }
1259                 if (nd->path.dentry != nd->path.mnt->mnt_root) {
1260                         /* rare case of legitimate dget_parent()... */
1261                         nd->path.dentry = dget_parent(nd->path.dentry);
1262                         dput(old);
1263                         break;
1264                 }
1265                 if (!follow_up(&nd->path))
1266                         break;
1267         }
1268         follow_mount(&nd->path);
1269         nd->inode = nd->path.dentry->d_inode;
1270 }
1271 
1272 /*
1273  * This looks up the name in dcache, possibly revalidates the old dentry and
1274  * allocates a new one if not found or not valid.  In the need_lookup argument
1275  * returns whether i_op->lookup is necessary.
1276  *
1277  * dir->d_inode->i_mutex must be held
1278  */
1279 static struct dentry *lookup_dcache(struct qstr *name, struct dentry *dir,
1280                                     unsigned int flags, bool *need_lookup)
1281 {
1282         struct dentry *dentry;
1283         int error;
1284 
1285         *need_lookup = false;
1286         dentry = d_lookup(dir, name);
1287         if (dentry) {
1288                 if (dentry->d_flags & DCACHE_OP_REVALIDATE) {
1289                         error = d_revalidate(dentry, flags);
1290                         if (unlikely(error <= 0)) {
1291                                 if (error < 0) {
1292                                         dput(dentry);
1293                                         return ERR_PTR(error);
1294                                 } else if (!d_invalidate(dentry)) {
1295                                         dput(dentry);
1296                                         dentry = NULL;
1297                                 }
1298                         }
1299                 }
1300         }
1301 
1302         if (!dentry) {
1303                 dentry = d_alloc(dir, name);
1304                 if (unlikely(!dentry))
1305                         return ERR_PTR(-ENOMEM);
1306 
1307                 *need_lookup = true;
1308         }
1309         return dentry;
1310 }
1311 
1312 /*
1313  * Call i_op->lookup on the dentry.  The dentry must be negative and
1314  * unhashed.
1315  *
1316  * dir->d_inode->i_mutex must be held
1317  */
1318 static struct dentry *lookup_real(struct inode *dir, struct dentry *dentry,
1319                                   unsigned int flags)
1320 {
1321         struct dentry *old;
1322 
1323         /* Don't create child dentry for a dead directory. */
1324         if (unlikely(IS_DEADDIR(dir))) {
1325                 dput(dentry);
1326                 return ERR_PTR(-ENOENT);
1327         }
1328 
1329         old = dir->i_op->lookup(dir, dentry, flags);
1330         if (unlikely(old)) {
1331                 dput(dentry);
1332                 dentry = old;
1333         }
1334         return dentry;
1335 }
1336 
1337 static struct dentry *__lookup_hash(struct qstr *name,
1338                 struct dentry *base, unsigned int flags)
1339 {
1340         bool need_lookup;
1341         struct dentry *dentry;
1342 
1343         dentry = lookup_dcache(name, base, flags, &need_lookup);
1344         if (!need_lookup)
1345                 return dentry;
1346 
1347         return lookup_real(base->d_inode, dentry, flags);
1348 }
1349 
1350 /*
1351  *  It's more convoluted than I'd like it to be, but... it's still fairly
1352  *  small and for now I'd prefer to have fast path as straight as possible.
1353  *  It _is_ time-critical.
1354  */
1355 static int lookup_fast(struct nameidata *nd,
1356                        struct path *path, struct inode **inode)
1357 {
1358         struct vfsmount *mnt = nd->path.mnt;
1359         struct dentry *dentry, *parent = nd->path.dentry;
1360         int need_reval = 1;
1361         int status = 1;
1362         int err;
1363 
1364         /*
1365          * Rename seqlock is not required here because in the off chance
1366          * of a false negative due to a concurrent rename, we're going to
1367          * do the non-racy lookup, below.
1368          */
1369         if (nd->flags & LOOKUP_RCU) {
1370                 unsigned seq;
1371                 dentry = __d_lookup_rcu(parent, &nd->last, &seq);
1372                 if (!dentry)
1373                         goto unlazy;
1374 
1375                 /*
1376                  * This sequence count validates that the inode matches
1377                  * the dentry name information from lookup.
1378                  */
1379                 *inode = dentry->d_inode;
1380                 if (read_seqcount_retry(&dentry->d_seq, seq))
1381                         return -ECHILD;
1382 
1383                 /*
1384                  * This sequence count validates that the parent had no
1385                  * changes while we did the lookup of the dentry above.
1386                  *
1387                  * The memory barrier in read_seqcount_begin of child is
1388                  *  enough, we can use __read_seqcount_retry here.
1389                  */
1390                 if (__read_seqcount_retry(&parent->d_seq, nd->seq))
1391                         return -ECHILD;
1392                 nd->seq = seq;
1393 
1394                 if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE)) {
1395                         status = d_revalidate(dentry, nd->flags);
1396                         if (unlikely(status <= 0)) {
1397                                 if (status != -ECHILD)
1398                                         need_reval = 0;
1399                                 goto unlazy;
1400                         }
1401                 }
1402                 path->mnt = mnt;
1403                 path->dentry = dentry;
1404                 if (unlikely(!__follow_mount_rcu(nd, path, inode)))
1405                         goto unlazy;
1406                 if (unlikely(path->dentry->d_flags & DCACHE_NEED_AUTOMOUNT))
1407                         goto unlazy;
1408                 return 0;
1409 unlazy:
1410                 if (unlazy_walk(nd, dentry))
1411                         return -ECHILD;
1412         } else {
1413                 dentry = __d_lookup(parent, &nd->last);
1414         }
1415 
1416         if (unlikely(!dentry))
1417                 goto need_lookup;
1418 
1419         if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE) && need_reval)
1420                 status = d_revalidate(dentry, nd->flags);
1421         if (unlikely(status <= 0)) {
1422                 if (status < 0) {
1423                         dput(dentry);
1424                         return status;
1425                 }
1426                 if (!d_invalidate(dentry)) {
1427                         dput(dentry);
1428                         goto need_lookup;
1429                 }
1430         }
1431 
1432         path->mnt = mnt;
1433         path->dentry = dentry;
1434         err = follow_managed(path, nd->flags);
1435         if (unlikely(err < 0)) {
1436                 path_put_conditional(path, nd);
1437                 return err;
1438         }
1439         if (err)
1440                 nd->flags |= LOOKUP_JUMPED;
1441         *inode = path->dentry->d_inode;
1442         return 0;
1443 
1444 need_lookup:
1445         return 1;
1446 }
1447 
1448 /* Fast lookup failed, do it the slow way */
1449 static int lookup_slow(struct nameidata *nd, struct path *path)
1450 {
1451         struct dentry *dentry, *parent;
1452         int err;
1453 
1454         parent = nd->path.dentry;
1455         BUG_ON(nd->inode != parent->d_inode);
1456 
1457         mutex_lock(&parent->d_inode->i_mutex);
1458         dentry = __lookup_hash(&nd->last, parent, nd->flags);
1459         mutex_unlock(&parent->d_inode->i_mutex);
1460         if (IS_ERR(dentry))
1461                 return PTR_ERR(dentry);
1462         path->mnt = nd->path.mnt;
1463         path->dentry = dentry;
1464         err = follow_managed(path, nd->flags);
1465         if (unlikely(err < 0)) {
1466                 path_put_conditional(path, nd);
1467                 return err;
1468         }
1469         if (err)
1470                 nd->flags |= LOOKUP_JUMPED;
1471         return 0;
1472 }
1473 
1474 static inline int may_lookup(struct nameidata *nd)
1475 {
1476         if (nd->flags & LOOKUP_RCU) {
1477                 int err = inode_permission(nd->inode, MAY_EXEC|MAY_NOT_BLOCK);
1478                 if (err != -ECHILD)
1479                         return err;
1480                 if (unlazy_walk(nd, NULL))
1481                         return -ECHILD;
1482         }
1483         return inode_permission(nd->inode, MAY_EXEC);
1484 }
1485 
1486 static inline int handle_dots(struct nameidata *nd, int type)
1487 {
1488         if (type == LAST_DOTDOT) {
1489                 if (nd->flags & LOOKUP_RCU) {
1490                         if (follow_dotdot_rcu(nd))
1491                                 return -ECHILD;
1492                 } else
1493                         follow_dotdot(nd);
1494         }
1495         return 0;
1496 }
1497 
1498 static void terminate_walk(struct nameidata *nd)
1499 {
1500         if (!(nd->flags & LOOKUP_RCU)) {
1501                 path_put(&nd->path);
1502         } else {
1503                 nd->flags &= ~LOOKUP_RCU;
1504                 if (!(nd->flags & LOOKUP_ROOT))
1505                         nd->root.mnt = NULL;
1506                 rcu_read_unlock();
1507         }
1508 }
1509 
1510 /*
1511  * Do we need to follow links? We _really_ want to be able
1512  * to do this check without having to look at inode->i_op,
1513  * so we keep a cache of "no, this doesn't need follow_link"
1514  * for the common case.
1515  */
1516 static inline int should_follow_link(struct dentry *dentry, int follow)
1517 {
1518         return unlikely(d_is_symlink(dentry)) ? follow : 0;
1519 }
1520 
1521 static inline int walk_component(struct nameidata *nd, struct path *path,
1522                 int follow)
1523 {
1524         struct inode *inode;
1525         int err;
1526         /*
1527          * "." and ".." are special - ".." especially so because it has
1528          * to be able to know about the current root directory and
1529          * parent relationships.
1530          */
1531         if (unlikely(nd->last_type != LAST_NORM))
1532                 return handle_dots(nd, nd->last_type);
1533         err = lookup_fast(nd, path, &inode);
1534         if (unlikely(err)) {
1535                 if (err < 0)
1536                         goto out_err;
1537 
1538                 err = lookup_slow(nd, path);
1539                 if (err < 0)
1540                         goto out_err;
1541 
1542                 inode = path->dentry->d_inode;
1543         }
1544         err = -ENOENT;
1545         if (!inode || d_is_negative(path->dentry))
1546                 goto out_path_put;
1547 
1548         if (should_follow_link(path->dentry, follow)) {
1549                 if (nd->flags & LOOKUP_RCU) {
1550                         if (unlikely(unlazy_walk(nd, path->dentry))) {
1551                                 err = -ECHILD;
1552                                 goto out_err;
1553                         }
1554                 }
1555                 BUG_ON(inode != path->dentry->d_inode);
1556                 return 1;
1557         }
1558         path_to_nameidata(path, nd);
1559         nd->inode = inode;
1560         return 0;
1561 
1562 out_path_put:
1563         path_to_nameidata(path, nd);
1564 out_err:
1565         terminate_walk(nd);
1566         return err;
1567 }
1568 
1569 /*
1570  * This limits recursive symlink follows to 8, while
1571  * limiting consecutive symlinks to 40.
1572  *
1573  * Without that kind of total limit, nasty chains of consecutive
1574  * symlinks can cause almost arbitrarily long lookups.
1575  */
1576 static inline int nested_symlink(struct path *path, struct nameidata *nd)
1577 {
1578         int res;
1579 
1580         if (unlikely(current->link_count >= MAX_NESTED_LINKS)) {
1581                 path_put_conditional(path, nd);
1582                 path_put(&nd->path);
1583                 return -ELOOP;
1584         }
1585         BUG_ON(nd->depth >= MAX_NESTED_LINKS);
1586 
1587         nd->depth++;
1588         current->link_count++;
1589 
1590         do {
1591                 struct path link = *path;
1592                 void *cookie;
1593 
1594                 res = follow_link(&link, nd, &cookie);
1595                 if (res)
1596                         break;
1597                 res = walk_component(nd, path, LOOKUP_FOLLOW);
1598                 put_link(nd, &link, cookie);
1599         } while (res > 0);
1600 
1601         current->link_count--;
1602         nd->depth--;
1603         return res;
1604 }
1605 
1606 /*
1607  * We can do the critical dentry name comparison and hashing
1608  * operations one word at a time, but we are limited to:
1609  *
1610  * - Architectures with fast unaligned word accesses. We could
1611  *   do a "get_unaligned()" if this helps and is sufficiently
1612  *   fast.
1613  *
1614  * - non-CONFIG_DEBUG_PAGEALLOC configurations (so that we
1615  *   do not trap on the (extremely unlikely) case of a page
1616  *   crossing operation.
1617  *
1618  * - Furthermore, we need an efficient 64-bit compile for the
1619  *   64-bit case in order to generate the "number of bytes in
1620  *   the final mask". Again, that could be replaced with a
1621  *   efficient population count instruction or similar.
1622  */
1623 #ifdef CONFIG_DCACHE_WORD_ACCESS
1624 
1625 #include <asm/word-at-a-time.h>
1626 
1627 #ifdef CONFIG_64BIT
1628 
1629 static inline unsigned int fold_hash(unsigned long hash)
1630 {
1631         hash += hash >> (8*sizeof(int));
1632         return hash;
1633 }
1634 
1635 #else   /* 32-bit case */
1636 
1637 #define fold_hash(x) (x)
1638 
1639 #endif
1640 
1641 unsigned int full_name_hash(const unsigned char *name, unsigned int len)
1642 {
1643         unsigned long a, mask;
1644         unsigned long hash = 0;
1645 
1646         for (;;) {
1647                 a = load_unaligned_zeropad(name);
1648                 if (len < sizeof(unsigned long))
1649                         break;
1650                 hash += a;
1651                 hash *= 9;
1652                 name += sizeof(unsigned long);
1653                 len -= sizeof(unsigned long);
1654                 if (!len)
1655                         goto done;
1656         }
1657         mask = bytemask_from_count(len);
1658         hash += mask & a;
1659 done:
1660         return fold_hash(hash);
1661 }
1662 EXPORT_SYMBOL(full_name_hash);
1663 
1664 /*
1665  * Calculate the length and hash of the path component, and
1666  * return the length of the component;
1667  */
1668 static inline unsigned long hash_name(const char *name, unsigned int *hashp)
1669 {
1670         unsigned long a, b, adata, bdata, mask, hash, len;
1671         const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
1672 
1673         hash = a = 0;
1674         len = -sizeof(unsigned long);
1675         do {
1676                 hash = (hash + a) * 9;
1677                 len += sizeof(unsigned long);
1678                 a = load_unaligned_zeropad(name+len);
1679                 b = a ^ REPEAT_BYTE('/');
1680         } while (!(has_zero(a, &adata, &constants) | has_zero(b, &bdata, &constants)));
1681 
1682         adata = prep_zero_mask(a, adata, &constants);
1683         bdata = prep_zero_mask(b, bdata, &constants);
1684 
1685         mask = create_zero_mask(adata | bdata);
1686 
1687         hash += a & zero_bytemask(mask);
1688         *hashp = fold_hash(hash);
1689 
1690         return len + find_zero(mask);
1691 }
1692 
1693 #else
1694 
1695 unsigned int full_name_hash(const unsigned char *name, unsigned int len)
1696 {
1697         unsigned long hash = init_name_hash();
1698         while (len--)
1699                 hash = partial_name_hash(*name++, hash);
1700         return end_name_hash(hash);
1701 }
1702 EXPORT_SYMBOL(full_name_hash);
1703 
1704 /*
1705  * We know there's a real path component here of at least
1706  * one character.
1707  */
1708 static inline unsigned long hash_name(const char *name, unsigned int *hashp)
1709 {
1710         unsigned long hash = init_name_hash();
1711         unsigned long len = 0, c;
1712 
1713         c = (unsigned char)*name;
1714         do {
1715                 len++;
1716                 hash = partial_name_hash(c, hash);
1717                 c = (unsigned char)name[len];
1718         } while (c && c != '/');
1719         *hashp = end_name_hash(hash);
1720         return len;
1721 }
1722 
1723 #endif
1724 
1725 /*
1726  * Name resolution.
1727  * This is the basic name resolution function, turning a pathname into
1728  * the final dentry. We expect 'base' to be positive and a directory.
1729  *
1730  * Returns 0 and nd will have valid dentry and mnt on success.
1731  * Returns error and drops reference to input namei data on failure.
1732  */
1733 static int link_path_walk(const char *name, struct nameidata *nd)
1734 {
1735         struct path next;
1736         int err;
1737         
1738         while (*name=='/')
1739                 name++;
1740         if (!*name)
1741                 return 0;
1742 
1743         /* At this point we know we have a real path component. */
1744         for(;;) {
1745                 struct qstr this;
1746                 long len;
1747                 int type;
1748 
1749                 err = may_lookup(nd);
1750                 if (err)
1751                         break;
1752 
1753                 len = hash_name(name, &this.hash);
1754                 this.name = name;
1755                 this.len = len;
1756 
1757                 type = LAST_NORM;
1758                 if (name[0] == '.') switch (len) {
1759                         case 2:
1760                                 if (name[1] == '.') {
1761                                         type = LAST_DOTDOT;
1762                                         nd->flags |= LOOKUP_JUMPED;
1763                                 }
1764                                 break;
1765                         case 1:
1766                                 type = LAST_DOT;
1767                 }
1768                 if (likely(type == LAST_NORM)) {
1769                         struct dentry *parent = nd->path.dentry;
1770                         nd->flags &= ~LOOKUP_JUMPED;
1771                         if (unlikely(parent->d_flags & DCACHE_OP_HASH)) {
1772                                 err = parent->d_op->d_hash(parent, &this);
1773                                 if (err < 0)
1774                                         break;
1775                         }
1776                 }
1777 
1778                 nd->last = this;
1779                 nd->last_type = type;
1780 
1781                 if (!name[len])
1782                         return 0;
1783                 /*
1784                  * If it wasn't NUL, we know it was '/'. Skip that
1785                  * slash, and continue until no more slashes.
1786                  */
1787                 do {
1788                         len++;
1789                 } while (unlikely(name[len] == '/'));
1790                 if (!name[len])
1791                         return 0;
1792 
1793                 name += len;
1794 
1795                 err = walk_component(nd, &next, LOOKUP_FOLLOW);
1796                 if (err < 0)
1797                         return err;
1798 
1799                 if (err) {
1800                         err = nested_symlink(&next, nd);
1801                         if (err)
1802                                 return err;
1803                 }
1804                 if (!d_can_lookup(nd->path.dentry)) {
1805                         err = -ENOTDIR; 
1806                         break;
1807                 }
1808         }
1809         terminate_walk(nd);
1810         return err;
1811 }
1812 
1813 static int path_init(int dfd, const char *name, unsigned int flags,
1814                      struct nameidata *nd, struct file **fp)
1815 {
1816         int retval = 0;
1817 
1818         nd->last_type = LAST_ROOT; /* if there are only slashes... */
1819         nd->flags = flags | LOOKUP_JUMPED;
1820         nd->depth = 0;
1821         if (flags & LOOKUP_ROOT) {
1822                 struct dentry *root = nd->root.dentry;
1823                 struct inode *inode = root->d_inode;
1824                 if (*name) {
1825                         if (!d_can_lookup(root))
1826                                 return -ENOTDIR;
1827                         retval = inode_permission(inode, MAY_EXEC);
1828                         if (retval)
1829                                 return retval;
1830                 }
1831                 nd->path = nd->root;
1832                 nd->inode = inode;
1833                 if (flags & LOOKUP_RCU) {
1834                         rcu_read_lock();
1835                         nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
1836                         nd->m_seq = read_seqbegin(&mount_lock);
1837                 } else {
1838                         path_get(&nd->path);
1839                 }
1840                 return 0;
1841         }
1842 
1843         nd->root.mnt = NULL;
1844 
1845         nd->m_seq = read_seqbegin(&mount_lock);
1846         if (*name=='/') {
1847                 if (flags & LOOKUP_RCU) {
1848                         rcu_read_lock();
1849                         set_root_rcu(nd);
1850                 } else {
1851                         set_root(nd);
1852                         path_get(&nd->root);
1853                 }
1854                 nd->path = nd->root;
1855         } else if (dfd == AT_FDCWD) {
1856                 if (flags & LOOKUP_RCU) {
1857                         struct fs_struct *fs = current->fs;
1858                         unsigned seq;
1859 
1860                         rcu_read_lock();
1861 
1862                         do {
1863                                 seq = read_seqcount_begin(&fs->seq);
1864                                 nd->path = fs->pwd;
1865                                 nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
1866                         } while (read_seqcount_retry(&fs->seq, seq));
1867                 } else {
1868                         get_fs_pwd(current->fs, &nd->path);
1869                 }
1870         } else {
1871                 /* Caller must check execute permissions on the starting path component */
1872                 struct fd f = fdget_raw(dfd);
1873                 struct dentry *dentry;
1874 
1875                 if (!f.file)
1876                         return -EBADF;
1877 
1878                 dentry = f.file->f_path.dentry;
1879 
1880                 if (*name) {
1881                         if (!d_can_lookup(dentry)) {
1882                                 fdput(f);
1883                                 return -ENOTDIR;
1884                         }
1885                 }
1886 
1887                 nd->path = f.file->f_path;
1888                 if (flags & LOOKUP_RCU) {
1889                         if (f.flags & FDPUT_FPUT)
1890                                 *fp = f.file;
1891                         nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
1892                         rcu_read_lock();
1893                 } else {
1894                         path_get(&nd->path);
1895                         fdput(f);
1896                 }
1897         }
1898 
1899         nd->inode = nd->path.dentry->d_inode;
1900         return 0;
1901 }
1902 
1903 static inline int lookup_last(struct nameidata *nd, struct path *path)
1904 {
1905         if (nd->last_type == LAST_NORM && nd->last.name[nd->last.len])
1906                 nd->flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
1907 
1908         nd->flags &= ~LOOKUP_PARENT;
1909         return walk_component(nd, path, nd->flags & LOOKUP_FOLLOW);
1910 }
1911 
1912 /* Returns 0 and nd will be valid on success; Retuns error, otherwise. */
1913 static int path_lookupat(int dfd, const char *name,
1914                                 unsigned int flags, struct nameidata *nd)
1915 {
1916         struct file *base = NULL;
1917         struct path path;
1918         int err;
1919 
1920         /*
1921          * Path walking is largely split up into 2 different synchronisation
1922          * schemes, rcu-walk and ref-walk (explained in
1923          * Documentation/filesystems/path-lookup.txt). These share much of the
1924          * path walk code, but some things particularly setup, cleanup, and
1925          * following mounts are sufficiently divergent that functions are
1926          * duplicated. Typically there is a function foo(), and its RCU
1927          * analogue, foo_rcu().
1928          *
1929          * -ECHILD is the error number of choice (just to avoid clashes) that
1930          * is returned if some aspect of an rcu-walk fails. Such an error must
1931          * be handled by restarting a traditional ref-walk (which will always
1932          * be able to complete).
1933          */
1934         err = path_init(dfd, name, flags | LOOKUP_PARENT, nd, &base);
1935 
1936         if (unlikely(err))
1937                 return err;
1938 
1939         current->total_link_count = 0;
1940         err = link_path_walk(name, nd);
1941 
1942         if (!err && !(flags & LOOKUP_PARENT)) {
1943                 err = lookup_last(nd, &path);
1944                 while (err > 0) {
1945                         void *cookie;
1946                         struct path link = path;
1947                         err = may_follow_link(&link, nd);
1948                         if (unlikely(err))
1949                                 break;
1950                         nd->flags |= LOOKUP_PARENT;
1951                         err = follow_link(&link, nd, &cookie);
1952                         if (err)
1953                                 break;
1954                         err = lookup_last(nd, &path);
1955                         put_link(nd, &link, cookie);
1956                 }
1957         }
1958 
1959         if (!err)
1960                 err = complete_walk(nd);
1961 
1962         if (!err && nd->flags & LOOKUP_DIRECTORY) {
1963                 if (!d_can_lookup(nd->path.dentry)) {
1964                         path_put(&nd->path);
1965                         err = -ENOTDIR;
1966                 }
1967         }
1968 
1969         if (base)
1970                 fput(base);
1971 
1972         if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT)) {
1973                 path_put(&nd->root);
1974                 nd->root.mnt = NULL;
1975         }
1976         return err;
1977 }
1978 
1979 static int filename_lookup(int dfd, struct filename *name,
1980                                 unsigned int flags, struct nameidata *nd)
1981 {
1982         int retval = path_lookupat(dfd, name->name, flags | LOOKUP_RCU, nd);
1983         if (unlikely(retval == -ECHILD))
1984                 retval = path_lookupat(dfd, name->name, flags, nd);
1985         if (unlikely(retval == -ESTALE))
1986                 retval = path_lookupat(dfd, name->name,
1987                                                 flags | LOOKUP_REVAL, nd);
1988 
1989         if (likely(!retval))
1990                 audit_inode(name, nd->path.dentry, flags & LOOKUP_PARENT);
1991         return retval;
1992 }
1993 
1994 static int do_path_lookup(int dfd, const char *name,
1995                                 unsigned int flags, struct nameidata *nd)
1996 {
1997         struct filename filename = { .name = name };
1998 
1999         return filename_lookup(dfd, &filename, flags, nd);
2000 }
2001 
2002 /* does lookup, returns the object with parent locked */
2003 struct dentry *kern_path_locked(const char *name, struct path *path)
2004 {
2005         struct nameidata nd;
2006         struct dentry *d;
2007         int err = do_path_lookup(AT_FDCWD, name, LOOKUP_PARENT, &nd);
2008         if (err)
2009                 return ERR_PTR(err);
2010         if (nd.last_type != LAST_NORM) {
2011                 path_put(&nd.path);
2012                 return ERR_PTR(-EINVAL);
2013         }
2014         mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2015         d = __lookup_hash(&nd.last, nd.path.dentry, 0);
2016         if (IS_ERR(d)) {
2017                 mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2018                 path_put(&nd.path);
2019                 return d;
2020         }
2021         *path = nd.path;
2022         return d;
2023 }
2024 
2025 int kern_path(const char *name, unsigned int flags, struct path *path)
2026 {
2027         struct nameidata nd;
2028         int res = do_path_lookup(AT_FDCWD, name, flags, &nd);
2029         if (!res)
2030                 *path = nd.path;
2031         return res;
2032 }
2033 EXPORT_SYMBOL(kern_path);
2034 
2035 /**
2036  * vfs_path_lookup - lookup a file path relative to a dentry-vfsmount pair
2037  * @dentry:  pointer to dentry of the base directory
2038  * @mnt: pointer to vfs mount of the base directory
2039  * @name: pointer to file name
2040  * @flags: lookup flags
2041  * @path: pointer to struct path to fill
2042  */
2043 int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt,
2044                     const char *name, unsigned int flags,
2045                     struct path *path)
2046 {
2047         struct nameidata nd;
2048         int err;
2049         nd.root.dentry = dentry;
2050         nd.root.mnt = mnt;
2051         BUG_ON(flags & LOOKUP_PARENT);
2052         /* the first argument of do_path_lookup() is ignored with LOOKUP_ROOT */
2053         err = do_path_lookup(AT_FDCWD, name, flags | LOOKUP_ROOT, &nd);
2054         if (!err)
2055                 *path = nd.path;
2056         return err;
2057 }
2058 EXPORT_SYMBOL(vfs_path_lookup);
2059 
2060 /*
2061  * Restricted form of lookup. Doesn't follow links, single-component only,
2062  * needs parent already locked. Doesn't follow mounts.
2063  * SMP-safe.
2064  */
2065 static struct dentry *lookup_hash(struct nameidata *nd)
2066 {
2067         return __lookup_hash(&nd->last, nd->path.dentry, nd->flags);
2068 }
2069 
2070 /**
2071  * lookup_one_len - filesystem helper to lookup single pathname component
2072  * @name:       pathname component to lookup
2073  * @base:       base directory to lookup from
2074  * @len:        maximum length @len should be interpreted to
2075  *
2076  * Note that this routine is purely a helper for filesystem usage and should
2077  * not be called by generic code.  Also note that by using this function the
2078  * nameidata argument is passed to the filesystem methods and a filesystem
2079  * using this helper needs to be prepared for that.
2080  */
2081 struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)
2082 {
2083         struct qstr this;
2084         unsigned int c;
2085         int err;
2086 
2087         WARN_ON_ONCE(!mutex_is_locked(&base->d_inode->i_mutex));
2088 
2089         this.name = name;
2090         this.len = len;
2091         this.hash = full_name_hash(name, len);
2092         if (!len)
2093                 return ERR_PTR(-EACCES);
2094 
2095         if (unlikely(name[0] == '.')) {
2096                 if (len < 2 || (len == 2 && name[1] == '.'))
2097                         return ERR_PTR(-EACCES);
2098         }
2099 
2100         while (len--) {
2101                 c = *(const unsigned char *)name++;
2102                 if (c == '/' || c == '\0')
2103                         return ERR_PTR(-EACCES);
2104         }
2105         /*
2106          * See if the low-level filesystem might want
2107          * to use its own hash..
2108          */
2109         if (base->d_flags & DCACHE_OP_HASH) {
2110                 int err = base->d_op->d_hash(base, &this);
2111                 if (err < 0)
2112                         return ERR_PTR(err);
2113         }
2114 
2115         err = inode_permission(base->d_inode, MAY_EXEC);
2116         if (err)
2117                 return ERR_PTR(err);
2118 
2119         return __lookup_hash(&this, base, 0);
2120 }
2121 EXPORT_SYMBOL(lookup_one_len);
2122 
2123 int user_path_at_empty(int dfd, const char __user *name, unsigned flags,
2124                  struct path *path, int *empty)
2125 {
2126         struct nameidata nd;
2127         struct filename *tmp = getname_flags(name, flags, empty);
2128         int err = PTR_ERR(tmp);
2129         if (!IS_ERR(tmp)) {
2130 
2131                 BUG_ON(flags & LOOKUP_PARENT);
2132 
2133                 err = filename_lookup(dfd, tmp, flags, &nd);
2134                 putname(tmp);
2135                 if (!err)
2136                         *path = nd.path;
2137         }
2138         return err;
2139 }
2140 
2141 int user_path_at(int dfd, const char __user *name, unsigned flags,
2142                  struct path *path)
2143 {
2144         return user_path_at_empty(dfd, name, flags, path, NULL);
2145 }
2146 EXPORT_SYMBOL(user_path_at);
2147 
2148 /*
2149  * NB: most callers don't do anything directly with the reference to the
2150  *     to struct filename, but the nd->last pointer points into the name string
2151  *     allocated by getname. So we must hold the reference to it until all
2152  *     path-walking is complete.
2153  */
2154 static struct filename *
2155 user_path_parent(int dfd, const char __user *path, struct nameidata *nd,
2156                  unsigned int flags)
2157 {
2158         struct filename *s = getname(path);
2159         int error;
2160 
2161         /* only LOOKUP_REVAL is allowed in extra flags */
2162         flags &= LOOKUP_REVAL;
2163 
2164         if (IS_ERR(s))
2165                 return s;
2166 
2167         error = filename_lookup(dfd, s, flags | LOOKUP_PARENT, nd);
2168         if (error) {
2169                 putname(s);
2170                 return ERR_PTR(error);
2171         }
2172 
2173         return s;
2174 }
2175 
2176 /**
2177  * mountpoint_last - look up last component for umount
2178  * @nd:   pathwalk nameidata - currently pointing at parent directory of "last"
2179  * @path: pointer to container for result
2180  *
2181  * This is a special lookup_last function just for umount. In this case, we
2182  * need to resolve the path without doing any revalidation.
2183  *
2184  * The nameidata should be the result of doing a LOOKUP_PARENT pathwalk. Since
2185  * mountpoints are always pinned in the dcache, their ancestors are too. Thus,
2186  * in almost all cases, this lookup will be served out of the dcache. The only
2187  * cases where it won't are if nd->last refers to a symlink or the path is
2188  * bogus and it doesn't exist.
2189  *
2190  * Returns:
2191  * -error: if there was an error during lookup. This includes -ENOENT if the
2192  *         lookup found a negative dentry. The nd->path reference will also be
2193  *         put in this case.
2194  *
2195  * 0:      if we successfully resolved nd->path and found it to not to be a
2196  *         symlink that needs to be followed. "path" will also be populated.
2197  *         The nd->path reference will also be put.
2198  *
2199  * 1:      if we successfully resolved nd->last and found it to be a symlink
2200  *         that needs to be followed. "path" will be populated with the path
2201  *         to the link, and nd->path will *not* be put.
2202  */
2203 static int
2204 mountpoint_last(struct nameidata *nd, struct path *path)
2205 {
2206         int error = 0;
2207         struct dentry *dentry;
2208         struct dentry *dir = nd->path.dentry;
2209 
2210         /* If we're in rcuwalk, drop out of it to handle last component */
2211         if (nd->flags & LOOKUP_RCU) {
2212                 if (unlazy_walk(nd, NULL)) {
2213                         error = -ECHILD;
2214                         goto out;
2215                 }
2216         }
2217 
2218         nd->flags &= ~LOOKUP_PARENT;
2219 
2220         if (unlikely(nd->last_type != LAST_NORM)) {
2221                 error = handle_dots(nd, nd->last_type);
2222                 if (error)
2223                         goto out;
2224                 dentry = dget(nd->path.dentry);
2225                 goto done;
2226         }
2227 
2228         mutex_lock(&dir->d_inode->i_mutex);
2229         dentry = d_lookup(dir, &nd->last);
2230         if (!dentry) {
2231                 /*
2232                  * No cached dentry. Mounted dentries are pinned in the cache,
2233                  * so that means that this dentry is probably a symlink or the
2234                  * path doesn't actually point to a mounted dentry.
2235                  */
2236                 dentry = d_alloc(dir, &nd->last);
2237                 if (!dentry) {
2238                         error = -ENOMEM;
2239                         mutex_unlock(&dir->d_inode->i_mutex);
2240                         goto out;
2241                 }
2242                 dentry = lookup_real(dir->d_inode, dentry, nd->flags);
2243                 error = PTR_ERR(dentry);
2244                 if (IS_ERR(dentry)) {
2245                         mutex_unlock(&dir->d_inode->i_mutex);
2246                         goto out;
2247                 }
2248         }
2249         mutex_unlock(&dir->d_inode->i_mutex);
2250 
2251 done:
2252         if (!dentry->d_inode || d_is_negative(dentry)) {
2253                 error = -ENOENT;
2254                 dput(dentry);
2255                 goto out;
2256         }
2257         path->dentry = dentry;
2258         path->mnt = mntget(nd->path.mnt);
2259         if (should_follow_link(dentry, nd->flags & LOOKUP_FOLLOW))
2260                 return 1;
2261         follow_mount(path);
2262         error = 0;
2263 out:
2264         terminate_walk(nd);
2265         return error;
2266 }
2267 
2268 /**
2269  * path_mountpoint - look up a path to be umounted
2270  * @dfd:        directory file descriptor to start walk from
2271  * @name:       full pathname to walk
2272  * @path:       pointer to container for result
2273  * @flags:      lookup flags
2274  *
2275  * Look up the given name, but don't attempt to revalidate the last component.
2276  * Returns 0 and "path" will be valid on success; Returns error otherwise.
2277  */
2278 static int
2279 path_mountpoint(int dfd, const char *name, struct path *path, unsigned int flags)
2280 {
2281         struct file *base = NULL;
2282         struct nameidata nd;
2283         int err;
2284 
2285         err = path_init(dfd, name, flags | LOOKUP_PARENT, &nd, &base);
2286         if (unlikely(err))
2287                 return err;
2288 
2289         current->total_link_count = 0;
2290         err = link_path_walk(name, &nd);
2291         if (err)
2292                 goto out;
2293 
2294         err = mountpoint_last(&nd, path);
2295         while (err > 0) {
2296                 void *cookie;
2297                 struct path link = *path;
2298                 err = may_follow_link(&link, &nd);
2299                 if (unlikely(err))
2300                         break;
2301                 nd.flags |= LOOKUP_PARENT;
2302                 err = follow_link(&link, &nd, &cookie);
2303                 if (err)
2304                         break;
2305                 err = mountpoint_last(&nd, path);
2306                 put_link(&nd, &link, cookie);
2307         }
2308 out:
2309         if (base)
2310                 fput(base);
2311 
2312         if (nd.root.mnt && !(nd.flags & LOOKUP_ROOT))
2313                 path_put(&nd.root);
2314 
2315         return err;
2316 }
2317 
2318 static int
2319 filename_mountpoint(int dfd, struct filename *s, struct path *path,
2320                         unsigned int flags)
2321 {
2322         int error = path_mountpoint(dfd, s->name, path, flags | LOOKUP_RCU);
2323         if (unlikely(error == -ECHILD))
2324                 error = path_mountpoint(dfd, s->name, path, flags);
2325         if (unlikely(error == -ESTALE))
2326                 error = path_mountpoint(dfd, s->name, path, flags | LOOKUP_REVAL);
2327         if (likely(!error))
2328                 audit_inode(s, path->dentry, 0);
2329         return error;
2330 }
2331 
2332 /**
2333  * user_path_mountpoint_at - lookup a path from userland in order to umount it
2334  * @dfd:        directory file descriptor
2335  * @name:       pathname from userland
2336  * @flags:      lookup flags
2337  * @path:       pointer to container to hold result
2338  *
2339  * A umount is a special case for path walking. We're not actually interested
2340  * in the inode in this situation, and ESTALE errors can be a problem. We
2341  * simply want track down the dentry and vfsmount attached at the mountpoint
2342  * and avoid revalidating the last component.
2343  *
2344  * Returns 0 and populates "path" on success.
2345  */
2346 int
2347 user_path_mountpoint_at(int dfd, const char __user *name, unsigned int flags,
2348                         struct path *path)
2349 {
2350         struct filename *s = getname(name);
2351         int error;
2352         if (IS_ERR(s))
2353                 return PTR_ERR(s);
2354         error = filename_mountpoint(dfd, s, path, flags);
2355         putname(s);
2356         return error;
2357 }
2358 
2359 int
2360 kern_path_mountpoint(int dfd, const char *name, struct path *path,
2361                         unsigned int flags)
2362 {
2363         struct filename s = {.name = name};
2364         return filename_mountpoint(dfd, &s, path, flags);
2365 }
2366 EXPORT_SYMBOL(kern_path_mountpoint);
2367 
2368 /*
2369  * It's inline, so penalty for filesystems that don't use sticky bit is
2370  * minimal.
2371  */
2372 static inline int check_sticky(struct inode *dir, struct inode *inode)
2373 {
2374         kuid_t fsuid = current_fsuid();
2375 
2376         if (!(dir->i_mode & S_ISVTX))
2377                 return 0;
2378         if (uid_eq(inode->i_uid, fsuid))
2379                 return 0;
2380         if (uid_eq(dir->i_uid, fsuid))
2381                 return 0;
2382         return !inode_capable(inode, CAP_FOWNER);
2383 }
2384 
2385 /*
2386  *      Check whether we can remove a link victim from directory dir, check
2387  *  whether the type of victim is right.
2388  *  1. We can't do it if dir is read-only (done in permission())
2389  *  2. We should have write and exec permissions on dir
2390  *  3. We can't remove anything from append-only dir
2391  *  4. We can't do anything with immutable dir (done in permission())
2392  *  5. If the sticky bit on dir is set we should either
2393  *      a. be owner of dir, or
2394  *      b. be owner of victim, or
2395  *      c. have CAP_FOWNER capability
2396  *  6. If the victim is append-only or immutable we can't do antyhing with
2397  *     links pointing to it.
2398  *  7. If we were asked to remove a directory and victim isn't one - ENOTDIR.
2399  *  8. If we were asked to remove a non-directory and victim isn't one - EISDIR.
2400  *  9. We can't remove a root or mountpoint.
2401  * 10. We don't allow removal of NFS sillyrenamed files; it's handled by
2402  *     nfs_async_unlink().
2403  */
2404 static int may_delete(struct inode *dir, struct dentry *victim, bool isdir)
2405 {
2406         struct inode *inode = victim->d_inode;
2407         int error;
2408 
2409         if (d_is_negative(victim))
2410                 return -ENOENT;
2411         BUG_ON(!inode);
2412 
2413         BUG_ON(victim->d_parent->d_inode != dir);
2414         audit_inode_child(dir, victim, AUDIT_TYPE_CHILD_DELETE);
2415 
2416         error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
2417         if (error)
2418                 return error;
2419         if (IS_APPEND(dir))
2420                 return -EPERM;
2421 
2422         if (check_sticky(dir, inode) || IS_APPEND(inode) ||
2423             IS_IMMUTABLE(inode) || IS_SWAPFILE(inode))
2424                 return -EPERM;
2425         if (isdir) {
2426                 if (!d_is_dir(victim))
2427                         return -ENOTDIR;
2428                 if (IS_ROOT(victim))
2429                         return -EBUSY;
2430         } else if (d_is_dir(victim))
2431                 return -EISDIR;
2432         if (IS_DEADDIR(dir))
2433                 return -ENOENT;
2434         if (victim->d_flags & DCACHE_NFSFS_RENAMED)
2435                 return -EBUSY;
2436         return 0;
2437 }
2438 
2439 /*      Check whether we can create an object with dentry child in directory
2440  *  dir.
2441  *  1. We can't do it if child already exists (open has special treatment for
2442  *     this case, but since we are inlined it's OK)
2443  *  2. We can't do it if dir is read-only (done in permission())
2444  *  3. We should have write and exec permissions on dir
2445  *  4. We can't do it if dir is immutable (done in permission())
2446  */
2447 static inline int may_create(struct inode *dir, struct dentry *child)
2448 {
2449         audit_inode_child(dir, child, AUDIT_TYPE_CHILD_CREATE);
2450         if (child->d_inode)
2451                 return -EEXIST;
2452         if (IS_DEADDIR(dir))
2453                 return -ENOENT;
2454         return inode_permission(dir, MAY_WRITE | MAY_EXEC);
2455 }
2456 
2457 /*
2458  * p1 and p2 should be directories on the same fs.
2459  */
2460 struct dentry *lock_rename(struct dentry *p1, struct dentry *p2)
2461 {
2462         struct dentry *p;
2463 
2464         if (p1 == p2) {
2465                 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
2466                 return NULL;
2467         }
2468 
2469         mutex_lock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
2470 
2471         p = d_ancestor(p2, p1);
2472         if (p) {
2473                 mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_PARENT);
2474                 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_CHILD);
2475                 return p;
2476         }
2477 
2478         p = d_ancestor(p1, p2);
2479         if (p) {
2480                 mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
2481                 mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
2482                 return p;
2483         }
2484 
2485         mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
2486         mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
2487         return NULL;
2488 }
2489 EXPORT_SYMBOL(lock_rename);
2490 
2491 void unlock_rename(struct dentry *p1, struct dentry *p2)
2492 {
2493         mutex_unlock(&p1->d_inode->i_mutex);
2494         if (p1 != p2) {
2495                 mutex_unlock(&p2->d_inode->i_mutex);
2496                 mutex_unlock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
2497         }
2498 }
2499 EXPORT_SYMBOL(unlock_rename);
2500 
2501 int vfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
2502                 bool want_excl)
2503 {
2504         int error = may_create(dir, dentry);
2505         if (error)
2506                 return error;
2507 
2508         if (!dir->i_op->create)
2509                 return -EACCES; /* shouldn't it be ENOSYS? */
2510         mode &= S_IALLUGO;
2511         mode |= S_IFREG;
2512         error = security_inode_create(dir, dentry, mode);
2513         if (error)
2514                 return error;
2515         error = dir->i_op->create(dir, dentry, mode, want_excl);
2516         if (!error)
2517                 fsnotify_create(dir, dentry);
2518         return error;
2519 }
2520 EXPORT_SYMBOL(vfs_create);
2521 
2522 static int may_open(struct path *path, int acc_mode, int flag)
2523 {
2524         struct dentry *dentry = path->dentry;
2525         struct inode *inode = dentry->d_inode;
2526         int error;
2527 
2528         /* O_PATH? */
2529         if (!acc_mode)
2530                 return 0;
2531 
2532         if (!inode)
2533                 return -ENOENT;
2534 
2535         switch (inode->i_mode & S_IFMT) {
2536         case S_IFLNK:
2537                 return -ELOOP;
2538         case S_IFDIR:
2539                 if (acc_mode & MAY_WRITE)
2540                         return -EISDIR;
2541                 break;
2542         case S_IFBLK:
2543         case S_IFCHR:
2544                 if (path->mnt->mnt_flags & MNT_NODEV)
2545                         return -EACCES;
2546                 /*FALLTHRU*/
2547         case S_IFIFO:
2548         case S_IFSOCK:
2549                 flag &= ~O_TRUNC;
2550                 break;
2551         }
2552 
2553         error = inode_permission(inode, acc_mode);
2554         if (error)
2555                 return error;
2556 
2557         /*
2558          * An append-only file must be opened in append mode for writing.
2559          */
2560         if (IS_APPEND(inode)) {
2561                 if  ((flag & O_ACCMODE) != O_RDONLY && !(flag & O_APPEND))
2562                         return -EPERM;
2563                 if (flag & O_TRUNC)
2564                         return -EPERM;
2565         }
2566 
2567         /* O_NOATIME can only be set by the owner or superuser */
2568         if (flag & O_NOATIME && !inode_owner_or_capable(inode))
2569                 return -EPERM;
2570 
2571         return 0;
2572 }
2573 
2574 static int handle_truncate(struct file *filp)
2575 {
2576         struct path *path = &filp->f_path;
2577         struct inode *inode = path->dentry->d_inode;
2578         int error = get_write_access(inode);
2579         if (error)
2580                 return error;
2581         /*
2582          * Refuse to truncate files with mandatory locks held on them.
2583          */
2584         error = locks_verify_locked(filp);
2585         if (!error)
2586                 error = security_path_truncate(path);
2587         if (!error) {
2588                 error = do_truncate(path->dentry, 0,
2589                                     ATTR_MTIME|ATTR_CTIME|ATTR_OPEN,
2590                                     filp);
2591         }
2592         put_write_access(inode);
2593         return error;
2594 }
2595 
2596 static inline int open_to_namei_flags(int flag)
2597 {
2598         if ((flag & O_ACCMODE) == 3)
2599                 flag--;
2600         return flag;
2601 }
2602 
2603 static int may_o_create(struct path *dir, struct dentry *dentry, umode_t mode)
2604 {
2605         int error = security_path_mknod(dir, dentry, mode, 0);
2606         if (error)
2607                 return error;
2608 
2609         error = inode_permission(dir->dentry->d_inode, MAY_WRITE | MAY_EXEC);
2610         if (error)
2611                 return error;
2612 
2613         return security_inode_create(dir->dentry->d_inode, dentry, mode);
2614 }
2615 
2616 /*
2617  * Attempt to atomically look up, create and open a file from a negative
2618  * dentry.
2619  *
2620  * Returns 0 if successful.  The file will have been created and attached to
2621  * @file by the filesystem calling finish_open().
2622  *
2623  * Returns 1 if the file was looked up only or didn't need creating.  The
2624  * caller will need to perform the open themselves.  @path will have been
2625  * updated to point to the new dentry.  This may be negative.
2626  *
2627  * Returns an error code otherwise.
2628  */
2629 static int atomic_open(struct nameidata *nd, struct dentry *dentry,
2630                         struct path *path, struct file *file,
2631                         const struct open_flags *op,
2632                         bool got_write, bool need_lookup,
2633                         int *opened)
2634 {
2635         struct inode *dir =  nd->path.dentry->d_inode;
2636         unsigned open_flag = open_to_namei_flags(op->open_flag);
2637         umode_t mode;
2638         int error;
2639         int acc_mode;
2640         int create_error = 0;
2641         struct dentry *const DENTRY_NOT_SET = (void *) -1UL;
2642         bool excl;
2643 
2644         BUG_ON(dentry->d_inode);
2645 
2646         /* Don't create child dentry for a dead directory. */
2647         if (unlikely(IS_DEADDIR(dir))) {
2648                 error = -ENOENT;
2649                 goto out;
2650         }
2651 
2652         mode = op->mode;
2653         if ((open_flag & O_CREAT) && !IS_POSIXACL(dir))
2654                 mode &= ~current_umask();
2655 
2656         excl = (open_flag & (O_EXCL | O_CREAT)) == (O_EXCL | O_CREAT);
2657         if (excl)
2658                 open_flag &= ~O_TRUNC;
2659 
2660         /*
2661          * Checking write permission is tricky, bacuse we don't know if we are
2662          * going to actually need it: O_CREAT opens should work as long as the
2663          * file exists.  But checking existence breaks atomicity.  The trick is
2664          * to check access and if not granted clear O_CREAT from the flags.
2665          *
2666          * Another problem is returing the "right" error value (e.g. for an
2667          * O_EXCL open we want to return EEXIST not EROFS).
2668          */
2669         if (((open_flag & (O_CREAT | O_TRUNC)) ||
2670             (open_flag & O_ACCMODE) != O_RDONLY) && unlikely(!got_write)) {
2671                 if (!(open_flag & O_CREAT)) {
2672                         /*
2673                          * No O_CREATE -> atomicity not a requirement -> fall
2674                          * back to lookup + open
2675                          */
2676                         goto no_open;
2677                 } else if (open_flag & (O_EXCL | O_TRUNC)) {
2678                         /* Fall back and fail with the right error */
2679                         create_error = -EROFS;
2680                         goto no_open;
2681                 } else {
2682                         /* No side effects, safe to clear O_CREAT */
2683                         create_error = -EROFS;
2684                         open_flag &= ~O_CREAT;
2685                 }
2686         }
2687 
2688         if (open_flag & O_CREAT) {
2689                 error = may_o_create(&nd->path, dentry, mode);
2690                 if (error) {
2691                         create_error = error;
2692                         if (open_flag & O_EXCL)
2693                                 goto no_open;
2694                         open_flag &= ~O_CREAT;
2695                 }
2696         }
2697 
2698         if (nd->flags & LOOKUP_DIRECTORY)
2699                 open_flag |= O_DIRECTORY;
2700 
2701         file->f_path.dentry = DENTRY_NOT_SET;
2702         file->f_path.mnt = nd->path.mnt;
2703         error = dir->i_op->atomic_open(dir, dentry, file, open_flag, mode,
2704                                       opened);
2705         if (error < 0) {
2706                 if (create_error && error == -ENOENT)
2707                         error = create_error;
2708                 goto out;
2709         }
2710 
2711         if (error) {    /* returned 1, that is */
2712                 if (WARN_ON(file->f_path.dentry == DENTRY_NOT_SET)) {
2713                         error = -EIO;
2714                         goto out;
2715                 }
2716                 if (file->f_path.dentry) {
2717                         dput(dentry);
2718                         dentry = file->f_path.dentry;
2719                 }
2720                 if (*opened & FILE_CREATED)
2721                         fsnotify_create(dir, dentry);
2722                 if (!dentry->d_inode) {
2723                         WARN_ON(*opened & FILE_CREATED);
2724                         if (create_error) {
2725                                 error = create_error;
2726                                 goto out;
2727                         }
2728                 } else {
2729                         if (excl && !(*opened & FILE_CREATED)) {
2730                                 error = -EEXIST;
2731                                 goto out;
2732                         }
2733                 }
2734                 goto looked_up;
2735         }
2736 
2737         /*
2738          * We didn't have the inode before the open, so check open permission
2739          * here.
2740          */
2741         acc_mode = op->acc_mode;
2742         if (*opened & FILE_CREATED) {
2743                 WARN_ON(!(open_flag & O_CREAT));
2744                 fsnotify_create(dir, dentry);
2745                 acc_mode = MAY_OPEN;
2746         }
2747         error = may_open(&file->f_path, acc_mode, open_flag);
2748         if (error)
2749                 fput(file);
2750 
2751 out:
2752         dput(dentry);
2753         return error;
2754 
2755 no_open:
2756         if (need_lookup) {
2757                 dentry = lookup_real(dir, dentry, nd->flags);
2758                 if (IS_ERR(dentry))
2759                         return PTR_ERR(dentry);
2760 
2761                 if (create_error) {
2762                         int open_flag = op->open_flag;
2763 
2764                         error = create_error;
2765                         if ((open_flag & O_EXCL)) {
2766                                 if (!dentry->d_inode)
2767                                         goto out;
2768                         } else if (!dentry->d_inode) {
2769                                 goto out;
2770                         } else if ((open_flag & O_TRUNC) &&
2771                                    S_ISREG(dentry->d_inode->i_mode)) {
2772                                 goto out;
2773                         }
2774                         /* will fail later, go on to get the right error */
2775                 }
2776         }
2777 looked_up:
2778         path->dentry = dentry;
2779         path->mnt = nd->path.mnt;
2780         return 1;
2781 }
2782 
2783 /*
2784  * Look up and maybe create and open the last component.
2785  *
2786  * Must be called with i_mutex held on parent.
2787  *
2788  * Returns 0 if the file was successfully atomically created (if necessary) and
2789  * opened.  In this case the file will be returned attached to @file.
2790  *
2791  * Returns 1 if the file was not completely opened at this time, though lookups
2792  * and creations will have been performed and the dentry returned in @path will
2793  * be positive upon return if O_CREAT was specified.  If O_CREAT wasn't
2794  * specified then a negative dentry may be returned.
2795  *
2796  * An error code is returned otherwise.
2797  *
2798  * FILE_CREATE will be set in @*opened if the dentry was created and will be
2799  * cleared otherwise prior to returning.
2800  */
2801 static int lookup_open(struct nameidata *nd, struct path *path,
2802                         struct file *file,
2803                         const struct open_flags *op,
2804                         bool got_write, int *opened)
2805 {
2806         struct dentry *dir = nd->path.dentry;
2807         struct inode *dir_inode = dir->d_inode;
2808         struct dentry *dentry;
2809         int error;
2810         bool need_lookup;
2811 
2812         *opened &= ~FILE_CREATED;
2813         dentry = lookup_dcache(&nd->last, dir, nd->flags, &need_lookup);
2814         if (IS_ERR(dentry))
2815                 return PTR_ERR(dentry);
2816 
2817         /* Cached positive dentry: will open in f_op->open */
2818         if (!need_lookup && dentry->d_inode)
2819                 goto out_no_open;
2820 
2821         if ((nd->flags & LOOKUP_OPEN) && dir_inode->i_op->atomic_open) {
2822                 return atomic_open(nd, dentry, path, file, op, got_write,
2823                                    need_lookup, opened);
2824         }
2825 
2826         if (need_lookup) {
2827                 BUG_ON(dentry->d_inode);
2828 
2829                 dentry = lookup_real(dir_inode, dentry, nd->flags);
2830                 if (IS_ERR(dentry))
2831                         return PTR_ERR(dentry);
2832         }
2833 
2834         /* Negative dentry, just create the file */
2835         if (!dentry->d_inode && (op->open_flag & O_CREAT)) {
2836                 umode_t mode = op->mode;
2837                 if (!IS_POSIXACL(dir->d_inode))
2838                         mode &= ~current_umask();
2839                 /*
2840                  * This write is needed to ensure that a
2841                  * rw->ro transition does not occur between
2842                  * the time when the file is created and when
2843                  * a permanent write count is taken through
2844                  * the 'struct file' in finish_open().
2845                  */
2846                 if (!got_write) {
2847                         error = -EROFS;
2848                         goto out_dput;
2849                 }
2850                 *opened |= FILE_CREATED;
2851                 error = security_path_mknod(&nd->path, dentry, mode, 0);
2852                 if (error)
2853                         goto out_dput;
2854                 error = vfs_create(dir->d_inode, dentry, mode,
2855                                    nd->flags & LOOKUP_EXCL);
2856                 if (error)
2857                         goto out_dput;
2858         }
2859 out_no_open:
2860         path->dentry = dentry;
2861         path->mnt = nd->path.mnt;
2862         return 1;
2863 
2864 out_dput:
2865         dput(dentry);
2866         return error;
2867 }
2868 
2869 /*
2870  * Handle the last step of open()
2871  */
2872 static int do_last(struct nameidata *nd, struct path *path,
2873                    struct file *file, const struct open_flags *op,
2874                    int *opened, struct filename *name)
2875 {
2876         struct dentry *dir = nd->path.dentry;
2877         int open_flag = op->open_flag;
2878         bool will_truncate = (open_flag & O_TRUNC) != 0;
2879         bool got_write = false;
2880         int acc_mode = op->acc_mode;
2881         struct inode *inode;
2882         bool symlink_ok = false;
2883         struct path save_parent = { .dentry = NULL, .mnt = NULL };
2884         bool retried = false;
2885         int error;
2886 
2887         nd->flags &= ~LOOKUP_PARENT;
2888         nd->flags |= op->intent;
2889 
2890         if (nd->last_type != LAST_NORM) {
2891                 error = handle_dots(nd, nd->last_type);
2892                 if (error)
2893                         return error;
2894                 goto finish_open;
2895         }
2896 
2897         if (!(open_flag & O_CREAT)) {
2898                 if (nd->last.name[nd->last.len])
2899                         nd->flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
2900                 if (open_flag & O_PATH && !(nd->flags & LOOKUP_FOLLOW))
2901                         symlink_ok = true;
2902                 /* we _can_ be in RCU mode here */
2903                 error = lookup_fast(nd, path, &inode);
2904                 if (likely(!error))
2905                         goto finish_lookup;
2906 
2907                 if (error < 0)
2908                         goto out;
2909 
2910                 BUG_ON(nd->inode != dir->d_inode);
2911         } else {
2912                 /* create side of things */
2913                 /*
2914                  * This will *only* deal with leaving RCU mode - LOOKUP_JUMPED
2915                  * has been cleared when we got to the last component we are
2916                  * about to look up
2917                  */
2918                 error = complete_walk(nd);
2919                 if (error)
2920                         return error;
2921 
2922                 audit_inode(name, dir, LOOKUP_PARENT);
2923                 error = -EISDIR;
2924                 /* trailing slashes? */
2925                 if (nd->last.name[nd->last.len])
2926                         goto out;
2927         }
2928 
2929 retry_lookup:
2930         if (op->open_flag & (O_CREAT | O_TRUNC | O_WRONLY | O_RDWR)) {
2931                 error = mnt_want_write(nd->path.mnt);
2932                 if (!error)
2933                         got_write = true;
2934                 /*
2935                  * do _not_ fail yet - we might not need that or fail with
2936                  * a different error; let lookup_open() decide; we'll be
2937                  * dropping this one anyway.
2938                  */
2939         }
2940         mutex_lock(&dir->d_inode->i_mutex);
2941         error = lookup_open(nd, path, file, op, got_write, opened);
2942         mutex_unlock(&dir->d_inode->i_mutex);
2943 
2944         if (error <= 0) {
2945                 if (error)
2946                         goto out;
2947 
2948                 if ((*opened & FILE_CREATED) ||
2949                     !S_ISREG(file_inode(file)->i_mode))
2950                         will_truncate = false;
2951 
2952                 audit_inode(name, file->f_path.dentry, 0);
2953                 goto opened;
2954         }
2955 
2956         if (*opened & FILE_CREATED) {
2957                 /* Don't check for write permission, don't truncate */
2958                 open_flag &= ~O_TRUNC;
2959                 will_truncate = false;
2960                 acc_mode = MAY_OPEN;
2961                 path_to_nameidata(path, nd);
2962                 goto finish_open_created;
2963         }
2964 
2965         /*
2966          * create/update audit record if it already exists.
2967          */
2968         if (d_is_positive(path->dentry))
2969                 audit_inode(name, path->dentry, 0);
2970 
2971         /*
2972          * If atomic_open() acquired write access it is dropped now due to
2973          * possible mount and symlink following (this might be optimized away if
2974          * necessary...)
2975          */
2976         if (got_write) {
2977                 mnt_drop_write(nd->path.mnt);
2978                 got_write = false;
2979         }
2980 
2981         error = -EEXIST;
2982         if ((open_flag & (O_EXCL | O_CREAT)) == (O_EXCL | O_CREAT))
2983                 goto exit_dput;
2984 
2985         error = follow_managed(path, nd->flags);
2986         if (error < 0)
2987                 goto exit_dput;
2988 
2989         if (error)
2990                 nd->flags |= LOOKUP_JUMPED;
2991 
2992         BUG_ON(nd->flags & LOOKUP_RCU);
2993         inode = path->dentry->d_inode;
2994 finish_lookup:
2995         /* we _can_ be in RCU mode here */
2996         error = -ENOENT;
2997         if (!inode || d_is_negative(path->dentry)) {
2998                 path_to_nameidata(path, nd);
2999                 goto out;
3000         }
3001 
3002         if (should_follow_link(path->dentry, !symlink_ok)) {
3003                 if (nd->flags & LOOKUP_RCU) {
3004                         if (unlikely(unlazy_walk(nd, path->dentry))) {
3005                                 error = -ECHILD;
3006                                 goto out;
3007                         }
3008                 }
3009                 BUG_ON(inode != path->dentry->d_inode);
3010                 return 1;
3011         }
3012 
3013         if ((nd->flags & LOOKUP_RCU) || nd->path.mnt != path->mnt) {
3014                 path_to_nameidata(path, nd);
3015         } else {
3016                 save_parent.dentry = nd->path.dentry;
3017                 save_parent.mnt = mntget(path->mnt);
3018                 nd->path.dentry = path->dentry;
3019 
3020         }
3021         nd->inode = inode;
3022         /* Why this, you ask?  _Now_ we might have grown LOOKUP_JUMPED... */
3023 finish_open:
3024         error = complete_walk(nd);
3025         if (error) {
3026                 path_put(&save_parent);
3027                 return error;
3028         }
3029         audit_inode(name, nd->path.dentry, 0);
3030         error = -EISDIR;
3031         if ((open_flag & O_CREAT) && d_is_dir(nd->path.dentry))
3032                 goto out;
3033         error = -ENOTDIR;
3034         if ((nd->flags & LOOKUP_DIRECTORY) && !d_can_lookup(nd->path.dentry))
3035                 goto out;
3036         if (!S_ISREG(nd->inode->i_mode))
3037                 will_truncate = false;
3038 
3039         if (will_truncate) {
3040                 error = mnt_want_write(nd->path.mnt);
3041                 if (error)
3042                         goto out;
3043                 got_write = true;
3044         }
3045 finish_open_created:
3046         error = may_open(&nd->path, acc_mode, open_flag);
3047         if (error)
3048                 goto out;
3049         file->f_path.mnt = nd->path.mnt;
3050         error = finish_open(file, nd->path.dentry, NULL, opened);
3051         if (error) {
3052                 if (error == -EOPENSTALE)
3053                         goto stale_open;
3054                 goto out;
3055         }
3056 opened:
3057         error = open_check_o_direct(file);
3058         if (error)
3059                 goto exit_fput;
3060         error = ima_file_check(file, op->acc_mode);
3061         if (error)
3062                 goto exit_fput;
3063 
3064         if (will_truncate) {
3065                 error = handle_truncate(file);
3066                 if (error)
3067                         goto exit_fput;
3068         }
3069 out:
3070         if (got_write)
3071                 mnt_drop_write(nd->path.mnt);
3072         path_put(&save_parent);
3073         terminate_walk(nd);
3074         return error;
3075 
3076 exit_dput:
3077         path_put_conditional(path, nd);
3078         goto out;
3079 exit_fput:
3080         fput(file);
3081         goto out;
3082 
3083 stale_open:
3084         /* If no saved parent or already retried then can't retry */
3085         if (!save_parent.dentry || retried)
3086                 goto out;
3087 
3088         BUG_ON(save_parent.dentry != dir);
3089         path_put(&nd->path);
3090         nd->path = save_parent;
3091         nd->inode = dir->d_inode;
3092         save_parent.mnt = NULL;
3093         save_parent.dentry = NULL;
3094         if (got_write) {
3095                 mnt_drop_write(nd->path.mnt);
3096                 got_write = false;
3097         }
3098         retried = true;
3099         goto retry_lookup;
3100 }
3101 
3102 static int do_tmpfile(int dfd, struct filename *pathname,
3103                 struct nameidata *nd, int flags,
3104                 const struct open_flags *op,
3105                 struct file *file, int *opened)
3106 {
3107         static const struct qstr name = QSTR_INIT("/", 1);
3108         struct dentry *dentry, *child;
3109         struct inode *dir;
3110         int error = path_lookupat(dfd, pathname->name,
3111                                   flags | LOOKUP_DIRECTORY, nd);
3112         if (unlikely(error))
3113                 return error;
3114         error = mnt_want_write(nd->path.mnt);
3115         if (unlikely(error))
3116                 goto out;
3117         /* we want directory to be writable */
3118         error = inode_permission(nd->inode, MAY_WRITE | MAY_EXEC);
3119         if (error)
3120                 goto out2;
3121         dentry = nd->path.dentry;
3122         dir = dentry->d_inode;
3123         if (!dir->i_op->tmpfile) {
3124                 error = -EOPNOTSUPP;
3125                 goto out2;
3126         }
3127         child = d_alloc(dentry, &name);
3128         if (unlikely(!child)) {
3129                 error = -ENOMEM;
3130                 goto out2;
3131         }
3132         nd->flags &= ~LOOKUP_DIRECTORY;
3133         nd->flags |= op->intent;
3134         dput(nd->path.dentry);
3135         nd->path.dentry = child;
3136         error = dir->i_op->tmpfile(dir, nd->path.dentry, op->mode);
3137         if (error)
3138                 goto out2;
3139         audit_inode(pathname, nd->path.dentry, 0);
3140         error = may_open(&nd->path, op->acc_mode, op->open_flag);
3141         if (error)
3142                 goto out2;
3143         file->f_path.mnt = nd->path.mnt;
3144         error = finish_open(file, nd->path.dentry, NULL, opened);
3145         if (error)
3146                 goto out2;
3147         error = open_check_o_direct(file);
3148         if (error) {
3149                 fput(file);
3150         } else if (!(op->open_flag & O_EXCL)) {
3151                 struct inode *inode = file_inode(file);
3152                 spin_lock(&inode->i_lock);
3153                 inode->i_state |= I_LINKABLE;
3154                 spin_unlock(&inode->i_lock);
3155         }
3156 out2:
3157         mnt_drop_write(nd->path.mnt);
3158 out:
3159         path_put(&nd->path);
3160         return error;
3161 }
3162 
3163 static struct file *path_openat(int dfd, struct filename *pathname,
3164                 struct nameidata *nd, const struct open_flags *op, int flags)
3165 {
3166         struct file *base = NULL;
3167         struct file *file;
3168         struct path path;
3169         int opened = 0;
3170         int error;
3171 
3172         file = get_empty_filp();
3173         if (IS_ERR(file))
3174                 return file;
3175 
3176         file->f_flags = op->open_flag;
3177 
3178         if (unlikely(file->f_flags & __O_TMPFILE)) {
3179                 error = do_tmpfile(dfd, pathname, nd, flags, op, file, &opened);
3180                 goto out;
3181         }
3182 
3183         error = path_init(dfd, pathname->name, flags | LOOKUP_PARENT, nd, &base);
3184         if (unlikely(error))
3185                 goto out;
3186 
3187         current->total_link_count = 0;
3188         error = link_path_walk(pathname->name, nd);
3189         if (unlikely(error))
3190                 goto out;
3191 
3192         error = do_last(nd, &path, file, op, &opened, pathname);
3193         while (unlikely(error > 0)) { /* trailing symlink */
3194                 struct path link = path;
3195                 void *cookie;
3196                 if (!(nd->flags & LOOKUP_FOLLOW)) {
3197                         path_put_conditional(&path, nd);
3198                         path_put(&nd->path);
3199                         error = -ELOOP;
3200                         break;
3201                 }
3202                 error = may_follow_link(&link, nd);
3203                 if (unlikely(error))
3204                         break;
3205                 nd->flags |= LOOKUP_PARENT;
3206                 nd->flags &= ~(LOOKUP_OPEN|LOOKUP_CREATE|LOOKUP_EXCL);
3207                 error = follow_link(&link, nd, &cookie);
3208                 if (unlikely(error))
3209                         break;
3210                 error = do_last(nd, &path, file, op, &opened, pathname);
3211                 put_link(nd, &link, cookie);
3212         }
3213 out:
3214         if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT))
3215                 path_put(&nd->root);
3216         if (base)
3217                 fput(base);
3218         if (!(opened & FILE_OPENED)) {
3219                 BUG_ON(!error);
3220                 put_filp(file);
3221         }
3222         if (unlikely(error)) {
3223                 if (error == -EOPENSTALE) {
3224                         if (flags & LOOKUP_RCU)
3225                                 error = -ECHILD;
3226                         else
3227                                 error = -ESTALE;
3228                 }
3229                 file = ERR_PTR(error);
3230         }
3231         return file;
3232 }
3233 
3234 struct file *do_filp_open(int dfd, struct filename *pathname,
3235                 const struct open_flags *op)
3236 {
3237         struct nameidata nd;
3238         int flags = op->lookup_flags;
3239         struct file *filp;
3240 
3241         filp = path_openat(dfd, pathname, &nd, op, flags | LOOKUP_RCU);
3242         if (unlikely(filp == ERR_PTR(-ECHILD)))
3243                 filp = path_openat(dfd, pathname, &nd, op, flags);
3244         if (unlikely(filp == ERR_PTR(-ESTALE)))
3245                 filp = path_openat(dfd, pathname, &nd, op, flags | LOOKUP_REVAL);
3246         return filp;
3247 }
3248 
3249 struct file *do_file_open_root(struct dentry *dentry, struct vfsmount *mnt,
3250                 const char *name, const struct open_flags *op)
3251 {
3252         struct nameidata nd;
3253         struct file *file;
3254         struct filename filename = { .name = name };
3255         int flags = op->lookup_flags | LOOKUP_ROOT;
3256 
3257         nd.root.mnt = mnt;
3258         nd.root.dentry = dentry;
3259 
3260         if (d_is_symlink(dentry) && op->intent & LOOKUP_OPEN)
3261                 return ERR_PTR(-ELOOP);
3262 
3263         file = path_openat(-1, &filename, &nd, op, flags | LOOKUP_RCU);
3264         if (unlikely(file == ERR_PTR(-ECHILD)))
3265                 file = path_openat(-1, &filename, &nd, op, flags);
3266         if (unlikely(file == ERR_PTR(-ESTALE)))
3267                 file = path_openat(-1, &filename, &nd, op, flags | LOOKUP_REVAL);
3268         return file;
3269 }
3270 
3271 struct dentry *kern_path_create(int dfd, const char *pathname,
3272                                 struct path *path, unsigned int lookup_flags)
3273 {
3274         struct dentry *dentry = ERR_PTR(-EEXIST);
3275         struct nameidata nd;
3276         int err2;
3277         int error;
3278         bool is_dir = (lookup_flags & LOOKUP_DIRECTORY);
3279 
3280         /*
3281          * Note that only LOOKUP_REVAL and LOOKUP_DIRECTORY matter here. Any
3282          * other flags passed in are ignored!
3283          */
3284         lookup_flags &= LOOKUP_REVAL;
3285 
3286         error = do_path_lookup(dfd, pathname, LOOKUP_PARENT|lookup_flags, &nd);
3287         if (error)
3288                 return ERR_PTR(error);
3289 
3290         /*
3291          * Yucky last component or no last component at all?
3292          * (foo/., foo/.., /////)
3293          */
3294         if (nd.last_type != LAST_NORM)
3295                 goto out;
3296         nd.flags &= ~LOOKUP_PARENT;
3297         nd.flags |= LOOKUP_CREATE | LOOKUP_EXCL;
3298 
3299         /* don't fail immediately if it's r/o, at least try to report other errors */
3300         err2 = mnt_want_write(nd.path.mnt);
3301         /*
3302          * Do the final lookup.
3303          */
3304         mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
3305         dentry = lookup_hash(&nd);
3306         if (IS_ERR(dentry))
3307                 goto unlock;
3308 
3309         error = -EEXIST;
3310         if (d_is_positive(dentry))
3311                 goto fail;
3312 
3313         /*
3314          * Special case - lookup gave negative, but... we had foo/bar/
3315          * From the vfs_mknod() POV we just have a negative dentry -
3316          * all is fine. Let's be bastards - you had / on the end, you've
3317          * been asking for (non-existent) directory. -ENOENT for you.
3318          */
3319         if (unlikely(!is_dir && nd.last.name[nd.last.len])) {
3320                 error = -ENOENT;
3321                 goto fail;
3322         }
3323         if (unlikely(err2)) {
3324                 error = err2;
3325                 goto fail;
3326         }
3327         *path = nd.path;
3328         return dentry;
3329 fail:
3330         dput(dentry);
3331         dentry = ERR_PTR(error);
3332 unlock:
3333         mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
3334         if (!err2)
3335                 mnt_drop_write(nd.path.mnt);
3336 out:
3337         path_put(&nd.path);
3338         return dentry;
3339 }
3340 EXPORT_SYMBOL(kern_path_create);
3341 
3342 void done_path_create(struct path *path, struct dentry *dentry)
3343 {
3344         dput(dentry);
3345         mutex_unlock(&path->dentry->d_inode->i_mutex);
3346         mnt_drop_write(path->mnt);
3347         path_put(path);
3348 }
3349 EXPORT_SYMBOL(done_path_create);
3350 
3351 struct dentry *user_path_create(int dfd, const char __user *pathname,
3352                                 struct path *path, unsigned int lookup_flags)
3353 {
3354         struct filename *tmp = getname(pathname);
3355         struct dentry *res;
3356         if (IS_ERR(tmp))
3357                 return ERR_CAST(tmp);
3358         res = kern_path_create(dfd, tmp->name, path, lookup_flags);
3359         putname(tmp);
3360         return res;
3361 }
3362 EXPORT_SYMBOL(user_path_create);
3363 
3364 int vfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
3365 {
3366         int error = may_create(dir, dentry);
3367 
3368         if (error)
3369                 return error;
3370 
3371         if ((S_ISCHR(mode) || S_ISBLK(mode)) && !capable(CAP_MKNOD))
3372                 return -EPERM;
3373 
3374         if (!dir->i_op->mknod)
3375                 return -EPERM;
3376 
3377         error = devcgroup_inode_mknod(mode, dev);
3378         if (error)
3379                 return error;
3380 
3381         error = security_inode_mknod(dir, dentry, mode, dev);
3382         if (error)
3383                 return error;
3384 
3385         error = dir->i_op->mknod(dir, dentry, mode, dev);
3386         if (!error)
3387                 fsnotify_create(dir, dentry);
3388         return error;
3389 }
3390 EXPORT_SYMBOL(vfs_mknod);
3391 
3392 static int may_mknod(umode_t mode)
3393 {
3394         switch (mode & S_IFMT) {
3395         case S_IFREG:
3396         case S_IFCHR:
3397         case S_IFBLK:
3398         case S_IFIFO:
3399         case S_IFSOCK:
3400         case 0: /* zero mode translates to S_IFREG */
3401                 return 0;
3402         case S_IFDIR:
3403                 return -EPERM;
3404         default:
3405                 return -EINVAL;
3406         }
3407 }
3408 
3409 SYSCALL_DEFINE4(mknodat, int, dfd, const char __user *, filename, umode_t, mode,
3410                 unsigned, dev)
3411 {
3412         struct dentry *dentry;
3413         struct path path;
3414         int error;
3415         unsigned int lookup_flags = 0;
3416 
3417         error = may_mknod(mode);
3418         if (error)
3419                 return error;
3420 retry:
3421         dentry = user_path_create(dfd, filename, &path, lookup_flags);
3422         if (IS_ERR(dentry))
3423                 return PTR_ERR(dentry);
3424 
3425         if (!IS_POSIXACL(path.dentry->d_inode))
3426                 mode &= ~current_umask();
3427         error = security_path_mknod(&path, dentry, mode, dev);
3428         if (error)
3429                 goto out;
3430         switch (mode & S_IFMT) {
3431                 case 0: case S_IFREG:
3432                         error = vfs_create(path.dentry->d_inode,dentry,mode,true);
3433                         break;
3434                 case S_IFCHR: case S_IFBLK:
3435                         error = vfs_mknod(path.dentry->d_inode,dentry,mode,
3436                                         new_decode_dev(dev));
3437                         break;
3438                 case S_IFIFO: case S_IFSOCK:
3439                         error = vfs_mknod(path.dentry->d_inode,dentry,mode,0);
3440                         break;
3441         }
3442 out:
3443         done_path_create(&path, dentry);
3444         if (retry_estale(error, lookup_flags)) {
3445                 lookup_flags |= LOOKUP_REVAL;
3446                 goto retry;
3447         }
3448         return error;
3449 }
3450 
3451 SYSCALL_DEFINE3(mknod, const char __user *, filename, umode_t, mode, unsigned, dev)
3452 {
3453         return sys_mknodat(AT_FDCWD, filename, mode, dev);
3454 }
3455 
3456 int vfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
3457 {
3458         int error = may_create(dir, dentry);
3459         unsigned max_links = dir->i_sb->s_max_links;
3460 
3461         if (error)
3462                 return error;
3463 
3464         if (!dir->i_op->mkdir)
3465                 return -EPERM;
3466 
3467         mode &= (S_IRWXUGO|S_ISVTX);
3468         error = security_inode_mkdir(dir, dentry, mode);
3469         if (error)
3470                 return error;
3471 
3472         if (max_links && dir->i_nlink >= max_links)
3473                 return -EMLINK;
3474 
3475         error = dir->i_op->mkdir(dir, dentry, mode);
3476         if (!error)
3477                 fsnotify_mkdir(dir, dentry);
3478         return error;
3479 }
3480 EXPORT_SYMBOL(vfs_mkdir);
3481 
3482 SYSCALL_DEFINE3(mkdirat, int, dfd, const char __user *, pathname, umode_t, mode)
3483 {
3484         struct dentry *dentry;
3485         struct path path;
3486         int error;
3487         unsigned int lookup_flags = LOOKUP_DIRECTORY;
3488 
3489 retry:
3490         dentry = user_path_create(dfd, pathname, &path, lookup_flags);
3491         if (IS_ERR(dentry))
3492                 return PTR_ERR(dentry);
3493 
3494         if (!IS_POSIXACL(path.dentry->d_inode))
3495                 mode &= ~current_umask();
3496         error = security_path_mkdir(&path, dentry, mode);
3497         if (!error)
3498                 error = vfs_mkdir(path.dentry->d_inode, dentry, mode);
3499         done_path_create(&path, dentry);
3500         if (retry_estale(error, lookup_flags)) {
3501                 lookup_flags |= LOOKUP_REVAL;
3502                 goto retry;
3503         }
3504         return error;
3505 }
3506 
3507 SYSCALL_DEFINE2(mkdir, const char __user *, pathname, umode_t, mode)
3508 {
3509         return sys_mkdirat(AT_FDCWD, pathname, mode);
3510 }
3511 
3512 /*
3513  * The dentry_unhash() helper will try to drop the dentry early: we
3514  * should have a usage count of 1 if we're the only user of this
3515  * dentry, and if that is true (possibly after pruning the dcache),
3516  * then we drop the dentry now.
3517  *
3518  * A low-level filesystem can, if it choses, legally
3519  * do a
3520  *
3521  *      if (!d_unhashed(dentry))
3522  *              return -EBUSY;
3523  *
3524  * if it cannot handle the case of removing a directory
3525  * that is still in use by something else..
3526  */
3527 void dentry_unhash(struct dentry *dentry)
3528 {
3529         shrink_dcache_parent(dentry);
3530         spin_lock(&dentry->d_lock);
3531         if (dentry->d_lockref.count == 1)
3532                 __d_drop(dentry);
3533         spin_unlock(&dentry->d_lock);
3534 }
3535 EXPORT_SYMBOL(dentry_unhash);
3536 
3537 int vfs_rmdir(struct inode *dir, struct dentry *dentry)
3538 {
3539         int error = may_delete(dir, dentry, 1);
3540 
3541         if (error)
3542                 return error;
3543 
3544         if (!dir->i_op->rmdir)
3545                 return -EPERM;
3546 
3547         dget(dentry);
3548         mutex_lock(&dentry->d_inode->i_mutex);
3549 
3550         error = -EBUSY;
3551         if (d_mountpoint(dentry))
3552                 goto out;
3553 
3554         error = security_inode_rmdir(dir, dentry);
3555         if (error)
3556                 goto out;
3557 
3558         shrink_dcache_parent(dentry);
3559         error = dir->i_op->rmdir(dir, dentry);
3560         if (error)
3561                 goto out;
3562 
3563         dentry->d_inode->i_flags |= S_DEAD;
3564         dont_mount(dentry);
3565 
3566 out:
3567         mutex_unlock(&dentry->d_inode->i_mutex);
3568         dput(dentry);
3569         if (!error)
3570                 d_delete(dentry);
3571         return error;
3572 }
3573 EXPORT_SYMBOL(vfs_rmdir);
3574 
3575 static long do_rmdir(int dfd, const char __user *pathname)
3576 {
3577         int error = 0;
3578         struct filename *name;
3579         struct dentry *dentry;
3580         struct nameidata nd;
3581         unsigned int lookup_flags = 0;
3582 retry:
3583         name = user_path_parent(dfd, pathname, &nd, lookup_flags);
3584         if (IS_ERR(name))
3585                 return PTR_ERR(name);
3586 
3587         switch(nd.last_type) {
3588         case LAST_DOTDOT:
3589                 error = -ENOTEMPTY;
3590                 goto exit1;
3591         case LAST_DOT:
3592                 error = -EINVAL;
3593                 goto exit1;
3594         case LAST_ROOT:
3595                 error = -EBUSY;
3596                 goto exit1;
3597         }
3598 
3599         nd.flags &= ~LOOKUP_PARENT;
3600         error = mnt_want_write(nd.path.mnt);
3601         if (error)
3602                 goto exit1;
3603 
3604         mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
3605         dentry = lookup_hash(&nd);
3606         error = PTR_ERR(dentry);
3607         if (IS_ERR(dentry))
3608                 goto exit2;
3609         if (!dentry->d_inode) {
3610                 error = -ENOENT;
3611                 goto exit3;
3612         }
3613         error = security_path_rmdir(&nd.path, dentry);
3614         if (error)
3615                 goto exit3;
3616         error = vfs_rmdir(nd.path.dentry->d_inode, dentry);
3617 exit3:
3618         dput(dentry);
3619 exit2:
3620         mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
3621         mnt_drop_write(nd.path.mnt);
3622 exit1:
3623         path_put(&nd.path);
3624         putname(name);
3625         if (retry_estale(error, lookup_flags)) {
3626                 lookup_flags |= LOOKUP_REVAL;
3627                 goto retry;
3628         }
3629         return error;
3630 }
3631 
3632 SYSCALL_DEFINE1(rmdir, const char __user *, pathname)
3633 {
3634         return do_rmdir(AT_FDCWD, pathname);
3635 }
3636 
3637 /**
3638  * vfs_unlink - unlink a filesystem object
3639  * @dir:        parent directory
3640  * @dentry:     victim
3641  * @delegated_inode: returns victim inode, if the inode is delegated.
3642  *
3643  * The caller must hold dir->i_mutex.
3644  *
3645  * If vfs_unlink discovers a delegation, it will return -EWOULDBLOCK and
3646  * return a reference to the inode in delegated_inode.  The caller
3647  * should then break the delegation on that inode and retry.  Because
3648  * breaking a delegation may take a long time, the caller should drop
3649  * dir->i_mutex before doing so.
3650  *
3651  * Alternatively, a caller may pass NULL for delegated_inode.  This may
3652  * be appropriate for callers that expect the underlying filesystem not
3653  * to be NFS exported.
3654  */
3655 int vfs_unlink(struct inode *dir, struct dentry *dentry, struct inode **delegated_inode)
3656 {
3657         struct inode *target = dentry->d_inode;
3658         int error = may_delete(dir, dentry, 0);
3659 
3660         if (error)
3661                 return error;
3662 
3663         if (!dir->i_op->unlink)
3664                 return -EPERM;
3665 
3666         mutex_lock(&target->i_mutex);
3667         if (d_mountpoint(dentry))
3668                 error = -EBUSY;
3669         else {
3670                 error = security_inode_unlink(dir, dentry);
3671                 if (!error) {
3672                         error = try_break_deleg(target, delegated_inode);
3673                         if (error)
3674                                 goto out;
3675                         error = dir->i_op->unlink(dir, dentry);
3676                         if (!error)
3677                                 dont_mount(dentry);
3678                 }
3679         }
3680 out:
3681         mutex_unlock(&target->i_mutex);
3682 
3683         /* We don't d_delete() NFS sillyrenamed files--they still exist. */
3684         if (!error && !(dentry->d_flags & DCACHE_NFSFS_RENAMED)) {
3685                 fsnotify_link_count(target);
3686                 d_delete(dentry);
3687         }
3688 
3689         return error;
3690 }
3691 EXPORT_SYMBOL(vfs_unlink);
3692 
3693 /*
3694  * Make sure that the actual truncation of the file will occur outside its
3695  * directory's i_mutex.  Truncate can take a long time if there is a lot of
3696  * writeout happening, and we don't want to prevent access to the directory
3697  * while waiting on the I/O.
3698  */
3699 static long do_unlinkat(int dfd, const char __user *pathname)
3700 {
3701         int error;
3702         struct filename *name;
3703         struct dentry *dentry;
3704         struct nameidata nd;
3705         struct inode *inode = NULL;
3706         struct inode *delegated_inode = NULL;
3707         unsigned int lookup_flags = 0;
3708 retry:
3709         name = user_path_parent(dfd, pathname, &nd, lookup_flags);
3710         if (IS_ERR(name))
3711                 return PTR_ERR(name);
3712 
3713         error = -EISDIR;
3714         if (nd.last_type != LAST_NORM)
3715                 goto exit1;
3716 
3717         nd.flags &= ~LOOKUP_PARENT;
3718         error = mnt_want_write(nd.path.mnt);
3719         if (error)
3720                 goto exit1;
3721 retry_deleg:
3722         mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
3723         dentry = lookup_hash(&nd);
3724         error = PTR_ERR(dentry);
3725         if (!IS_ERR(dentry)) {
3726                 /* Why not before? Because we want correct error value */
3727                 if (nd.last.name[nd.last.len])
3728                         goto slashes;
3729                 inode = dentry->d_inode;
3730                 if (d_is_negative(dentry))
3731                         goto slashes;
3732                 ihold(inode);
3733                 error = security_path_unlink(&nd.path, dentry);
3734                 if (error)
3735                         goto exit2;
3736                 error = vfs_unlink(nd.path.dentry->d_inode, dentry, &delegated_inode);
3737 exit2:
3738                 dput(dentry);
3739         }
3740         mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
3741         if (inode)
3742                 iput(inode);    /* truncate the inode here */
3743         inode = NULL;
3744         if (delegated_inode) {
3745                 error = break_deleg_wait(&delegated_inode);
3746                 if (!error)
3747                         goto retry_deleg;
3748         }
3749         mnt_drop_write(nd.path.mnt);
3750 exit1:
3751         path_put(&nd.path);
3752         putname(name);
3753         if (retry_estale(error, lookup_flags)) {
3754                 lookup_flags |= LOOKUP_REVAL;
3755                 inode = NULL;
3756                 goto retry;
3757         }
3758         return error;
3759 
3760 slashes:
3761         if (d_is_negative(dentry))
3762                 error = -ENOENT;
3763         else if (d_is_dir(dentry))
3764                 error = -EISDIR;
3765         else
3766                 error = -ENOTDIR;
3767         goto exit2;
3768 }
3769 
3770 SYSCALL_DEFINE3(unlinkat, int, dfd, const char __user *, pathname, int, flag)
3771 {
3772         if ((flag & ~AT_REMOVEDIR) != 0)
3773                 return -EINVAL;
3774 
3775         if (flag & AT_REMOVEDIR)
3776                 return do_rmdir(dfd, pathname);
3777 
3778         return do_unlinkat(dfd, pathname);
3779 }
3780 
3781 SYSCALL_DEFINE1(unlink, const char __user *, pathname)
3782 {
3783         return do_unlinkat(AT_FDCWD, pathname);
3784 }
3785 
3786 int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname)
3787 {
3788         int error = may_create(dir, dentry);
3789 
3790         if (error)
3791                 return error;
3792 
3793         if (!dir->i_op->symlink)
3794                 return -EPERM;
3795 
3796         error = security_inode_symlink(dir, dentry, oldname);
3797         if (error)
3798                 return error;
3799 
3800         error = dir->i_op->symlink(dir, dentry, oldname);
3801         if (!error)
3802                 fsnotify_create(dir, dentry);
3803         return error;
3804 }
3805 EXPORT_SYMBOL(vfs_symlink);
3806 
3807 SYSCALL_DEFINE3(symlinkat, const char __user *, oldname,
3808                 int, newdfd, const char __user *, newname)
3809 {
3810         int error;
3811         struct filename *from;
3812         struct dentry *dentry;
3813         struct path path;
3814         unsigned int lookup_flags = 0;
3815 
3816         from = getname(oldname);
3817         if (IS_ERR(from))
3818                 return PTR_ERR(from);
3819 retry:
3820         dentry = user_path_create(newdfd, newname, &path, lookup_flags);
3821         error = PTR_ERR(dentry);
3822         if (IS_ERR(dentry))
3823                 goto out_putname;
3824 
3825         error = security_path_symlink(&path, dentry, from->name);
3826         if (!error)
3827                 error = vfs_symlink(path.dentry->d_inode, dentry, from->name);
3828         done_path_create(&path, dentry);
3829         if (retry_estale(error, lookup_flags)) {
3830                 lookup_flags |= LOOKUP_REVAL;
3831                 goto retry;
3832         }
3833 out_putname:
3834         putname(from);
3835         return error;
3836 }
3837 
3838 SYSCALL_DEFINE2(symlink, const char __user *, oldname, const char __user *, newname)
3839 {
3840         return sys_symlinkat(oldname, AT_FDCWD, newname);
3841 }
3842 
3843 /**
3844  * vfs_link - create a new link
3845  * @old_dentry: object to be linked
3846  * @dir:        new parent
3847  * @new_dentry: where to create the new link
3848  * @delegated_inode: returns inode needing a delegation break
3849  *
3850  * The caller must hold dir->i_mutex
3851  *
3852  * If vfs_link discovers a delegation on the to-be-linked file in need
3853  * of breaking, it will return -EWOULDBLOCK and return a reference to the
3854  * inode in delegated_inode.  The caller should then break the delegation
3855  * and retry.  Because breaking a delegation may take a long time, the
3856  * caller should drop the i_mutex before doing so.
3857  *
3858  * Alternatively, a caller may pass NULL for delegated_inode.  This may
3859  * be appropriate for callers that expect the underlying filesystem not
3860  * to be NFS exported.
3861  */
3862 int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry, struct inode **delegated_inode)
3863 {
3864         struct inode *inode = old_dentry->d_inode;
3865         unsigned max_links = dir->i_sb->s_max_links;
3866         int error;
3867 
3868         if (!inode)
3869                 return -ENOENT;
3870 
3871         error = may_create(dir, new_dentry);
3872         if (error)
3873                 return error;
3874 
3875         if (dir->i_sb != inode->i_sb)
3876                 return -EXDEV;
3877 
3878         /*
3879          * A link to an append-only or immutable file cannot be created.
3880          */
3881         if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
3882                 return -EPERM;
3883         if (!dir->i_op->link)
3884                 return -EPERM;
3885         if (S_ISDIR(inode->i_mode))
3886                 return -EPERM;
3887 
3888         error = security_inode_link(old_dentry, dir, new_dentry);
3889         if (error)
3890                 return error;
3891 
3892         mutex_lock(&inode->i_mutex);
3893         /* Make sure we don't allow creating hardlink to an unlinked file */
3894         if (inode->i_nlink == 0 && !(inode->i_state & I_LINKABLE))
3895                 error =  -ENOENT;
3896         else if (max_links && inode->i_nlink >= max_links)
3897                 error = -EMLINK;
3898         else {
3899                 error = try_break_deleg(inode, delegated_inode);
3900                 if (!error)
3901                         error = dir->i_op->link(old_dentry, dir, new_dentry);
3902         }
3903 
3904         if (!error && (inode->i_state & I_LINKABLE)) {
3905                 spin_lock(&inode->i_lock);
3906                 inode->i_state &= ~I_LINKABLE;
3907                 spin_unlock(&inode->i_lock);
3908         }
3909         mutex_unlock(&inode->i_mutex);
3910         if (!error)
3911                 fsnotify_link(dir, inode, new_dentry);
3912         return error;
3913 }
3914 EXPORT_SYMBOL(vfs_link);
3915 
3916 /*
3917  * Hardlinks are often used in delicate situations.  We avoid
3918  * security-related surprises by not following symlinks on the
3919  * newname.  --KAB
3920  *
3921  * We don't follow them on the oldname either to be compatible
3922  * with linux 2.0, and to avoid hard-linking to directories
3923  * and other special files.  --ADM
3924  */
3925 SYSCALL_DEFINE5(linkat, int, olddfd, const char __user *, oldname,
3926                 int, newdfd, const char __user *, newname, int, flags)
3927 {
3928         struct dentry *new_dentry;
3929         struct path old_path, new_path;
3930         struct inode *delegated_inode = NULL;
3931         int how = 0;
3932         int error;
3933 
3934         if ((flags & ~(AT_SYMLINK_FOLLOW | AT_EMPTY_PATH)) != 0)
3935                 return -EINVAL;
3936         /*
3937          * To use null names we require CAP_DAC_READ_SEARCH
3938          * This ensures that not everyone will be able to create
3939          * handlink using the passed filedescriptor.
3940          */
3941         if (flags & AT_EMPTY_PATH) {
3942                 if (!capable(CAP_DAC_READ_SEARCH))
3943                         return -ENOENT;
3944                 how = LOOKUP_EMPTY;
3945         }
3946 
3947         if (flags & AT_SYMLINK_FOLLOW)
3948                 how |= LOOKUP_FOLLOW;
3949 retry:
3950         error = user_path_at(olddfd, oldname, how, &old_path);
3951         if (error)
3952                 return error;
3953 
3954         new_dentry = user_path_create(newdfd, newname, &new_path,
3955                                         (how & LOOKUP_REVAL));
3956         error = PTR_ERR(new_dentry);
3957         if (IS_ERR(new_dentry))
3958                 goto out;
3959 
3960         error = -EXDEV;
3961         if (old_path.mnt != new_path.mnt)
3962                 goto out_dput;
3963         error = may_linkat(&old_path);
3964         if (unlikely(error))
3965                 goto out_dput;
3966         error = security_path_link(old_path.dentry, &new_path, new_dentry);
3967         if (error)
3968                 goto out_dput;
3969         error = vfs_link(old_path.dentry, new_path.dentry->d_inode, new_dentry, &delegated_inode);
3970 out_dput:
3971         done_path_create(&new_path, new_dentry);
3972         if (delegated_inode) {
3973                 error = break_deleg_wait(&delegated_inode);
3974                 if (!error) {
3975                         path_put(&old_path);
3976                         goto retry;
3977                 }
3978         }
3979         if (retry_estale(error, how)) {
3980                 path_put(&old_path);
3981                 how |= LOOKUP_REVAL;
3982                 goto retry;
3983         }
3984 out:
3985         path_put(&old_path);
3986 
3987         return error;
3988 }
3989 
3990 SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newname)
3991 {
3992         return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0);
3993 }
3994 
3995 /**
3996  * vfs_rename - rename a filesystem object
3997  * @old_dir:    parent of source
3998  * @old_dentry: source
3999  * @new_dir:    parent of destination
4000  * @new_dentry: destination
4001  * @delegated_inode: returns an inode needing a delegation break
4002  * @flags:      rename flags
4003  *
4004  * The caller must hold multiple mutexes--see lock_rename()).
4005  *
4006  * If vfs_rename discovers a delegation in need of breaking at either
4007  * the source or destination, it will return -EWOULDBLOCK and return a
4008  * reference to the inode in delegated_inode.  The caller should then
4009  * break the delegation and retry.  Because breaking a delegation may
4010  * take a long time, the caller should drop all locks before doing
4011  * so.
4012  *
4013  * Alternatively, a caller may pass NULL for delegated_inode.  This may
4014  * be appropriate for callers that expect the underlying filesystem not
4015  * to be NFS exported.
4016  *
4017  * The worst of all namespace operations - renaming directory. "Perverted"
4018  * doesn't even start to describe it. Somebody in UCB had a heck of a trip...
4019  * Problems:
4020  *      a) we can get into loop creation. Check is done in is_subdir().
4021  *      b) race potential - two innocent renames can create a loop together.
4022  *         That's where 4.4 screws up. Current fix: serialization on
4023  *         sb->s_vfs_rename_mutex. We might be more accurate, but that's another
4024  *         story.
4025  *      c) we have to lock _four_ objects - parents and victim (if it exists),
4026  *         and source (if it is not a directory).
4027  *         And that - after we got ->i_mutex on parents (until then we don't know
4028  *         whether the target exists).  Solution: try to be smart with locking
4029  *         order for inodes.  We rely on the fact that tree topology may change
4030  *         only under ->s_vfs_rename_mutex _and_ that parent of the object we
4031  *         move will be locked.  Thus we can rank directories by the tree
4032  *         (ancestors first) and rank all non-directories after them.
4033  *         That works since everybody except rename does "lock parent, lookup,
4034  *         lock child" and rename is under ->s_vfs_rename_mutex.
4035  *         HOWEVER, it relies on the assumption that any object with ->lookup()
4036  *         has no more than 1 dentry.  If "hybrid" objects will ever appear,
4037  *         we'd better make sure that there's no link(2) for them.
4038  *      d) conversion from fhandle to dentry may come in the wrong moment - when
4039  *         we are removing the target. Solution: we will have to grab ->i_mutex
4040  *         in the fhandle_to_dentry code. [FIXME - current nfsfh.c relies on
4041  *         ->i_mutex on parents, which works but leads to some truly excessive
4042  *         locking].
4043  */
4044 int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
4045                struct inode *new_dir, struct dentry *new_dentry,
4046                struct inode **delegated_inode, unsigned int flags)
4047 {
4048         int error;
4049         bool is_dir = d_is_dir(old_dentry);
4050         const unsigned char *old_name;
4051         struct inode *source = old_dentry->d_inode;
4052         struct inode *target = new_dentry->d_inode;
4053         bool new_is_dir = false;
4054         unsigned max_links = new_dir->i_sb->s_max_links;
4055 
4056         if (source == target)
4057                 return 0;
4058 
4059         error = may_delete(old_dir, old_dentry, is_dir);
4060         if (error)
4061                 return error;
4062 
4063         if (!target) {
4064                 error = may_create(new_dir, new_dentry);
4065         } else {
4066                 new_is_dir = d_is_dir(new_dentry);
4067 
4068                 if (!(flags & RENAME_EXCHANGE))
4069                         error = may_delete(new_dir, new_dentry, is_dir);
4070                 else
4071                         error = may_delete(new_dir, new_dentry, new_is_dir);
4072         }
4073         if (error)
4074                 return error;
4075 
4076         if (!old_dir->i_op->rename)
4077                 return -EPERM;
4078 
4079         if (flags && !old_dir->i_op->rename2)
4080                 return -EINVAL;
4081 
4082         /*
4083          * If we are going to change the parent - check write permissions,
4084          * we'll need to flip '..'.
4085          */
4086         if (new_dir != old_dir) {
4087                 if (is_dir) {
4088                         error = inode_permission(source, MAY_WRITE);
4089                         if (error)
4090                                 return error;
4091                 }
4092                 if ((flags & RENAME_EXCHANGE) && new_is_dir) {
4093                         error = inode_permission(target, MAY_WRITE);
4094                         if (error)
4095                                 return error;
4096                 }
4097         }
4098 
4099         error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry,
4100                                       flags);
4101         if (error)
4102                 return error;
4103 
4104         old_name = fsnotify_oldname_init(old_dentry->d_name.name);
4105         dget(new_dentry);
4106         if (!is_dir || (flags & RENAME_EXCHANGE))
4107                 lock_two_nondirectories(source, target);
4108         else if (target)
4109                 mutex_lock(&target->i_mutex);
4110 
4111         error = -EBUSY;
4112         if (d_mountpoint(old_dentry) || d_mountpoint(new_dentry))
4113                 goto out;
4114 
4115         if (max_links && new_dir != old_dir) {
4116                 error = -EMLINK;
4117                 if (is_dir && !new_is_dir && new_dir->i_nlink >= max_links)
4118                         goto out;
4119                 if ((flags & RENAME_EXCHANGE) && !is_dir && new_is_dir &&
4120                     old_dir->i_nlink >= max_links)
4121                         goto out;
4122         }
4123         if (is_dir && !(flags & RENAME_EXCHANGE) && target)
4124                 shrink_dcache_parent(new_dentry);
4125         if (!is_dir) {
4126                 error = try_break_deleg(source, delegated_inode);
4127                 if (error)
4128                         goto out;
4129         }
4130         if (target && !new_is_dir) {
4131                 error = try_break_deleg(target, delegated_inode);
4132                 if (error)
4133                         goto out;
4134         }
4135         if (!flags) {
4136                 error = old_dir->i_op->rename(old_dir, old_dentry,
4137                                               new_dir, new_dentry);
4138         } else {
4139                 error = old_dir->i_op->rename2(old_dir, old_dentry,
4140                                                new_dir, new_dentry, flags);
4141         }
4142         if (error)
4143                 goto out;
4144 
4145         if (!(flags & RENAME_EXCHANGE) && target) {
4146                 if (is_dir)
4147                         target->i_flags |= S_DEAD;
4148                 dont_mount(new_dentry);
4149         }
4150         if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE)) {
4151                 if (!(flags & RENAME_EXCHANGE))
4152                         d_move(old_dentry, new_dentry);
4153                 else
4154                         d_exchange(old_dentry, new_dentry);
4155         }
4156 out:
4157         if (!is_dir || (flags & RENAME_EXCHANGE))
4158                 unlock_two_nondirectories(source, target);
4159         else if (target)
4160                 mutex_unlock(&target->i_mutex);
4161         dput(new_dentry);
4162         if (!error) {
4163                 fsnotify_move(old_dir, new_dir, old_name, is_dir,
4164                               !(flags & RENAME_EXCHANGE) ? target : NULL, old_dentry);
4165                 if (flags & RENAME_EXCHANGE) {
4166                         fsnotify_move(new_dir, old_dir, old_dentry->d_name.name,
4167                                       new_is_dir, NULL, new_dentry);
4168                 }
4169         }
4170         fsnotify_oldname_free(old_name);
4171 
4172         return error;
4173 }
4174 EXPORT_SYMBOL(vfs_rename);
4175 
4176 SYSCALL_DEFINE5(renameat2, int, olddfd, const char __user *, oldname,
4177                 int, newdfd, const char __user *, newname, unsigned int, flags)
4178 {
4179         struct dentry *old_dir, *new_dir;
4180         struct dentry *old_dentry, *new_dentry;
4181         struct dentry *trap;
4182         struct nameidata oldnd, newnd;
4183         struct inode *delegated_inode = NULL;
4184         struct filename *from;
4185         struct filename *to;
4186         unsigned int lookup_flags = 0;
4187         bool should_retry = false;
4188         int error;
4189 
4190         if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE))
4191                 return -EINVAL;
4192 
4193         if ((flags & RENAME_NOREPLACE) && (flags & RENAME_EXCHANGE))
4194                 return -EINVAL;
4195 
4196 retry:
4197         from = user_path_parent(olddfd, oldname, &oldnd, lookup_flags);
4198         if (IS_ERR(from)) {
4199                 error = PTR_ERR(from);
4200                 goto exit;
4201         }
4202 
4203         to = user_path_parent(newdfd, newname, &newnd, lookup_flags);
4204         if (IS_ERR(to)) {
4205                 error = PTR_ERR(to);
4206                 goto exit1;
4207         }
4208 
4209         error = -EXDEV;
4210         if (oldnd.path.mnt != newnd.path.mnt)
4211                 goto exit2;
4212 
4213         old_dir = oldnd.path.dentry;
4214         error = -EBUSY;
4215         if (oldnd.last_type != LAST_NORM)
4216                 goto exit2;
4217 
4218         new_dir = newnd.path.dentry;
4219         if (flags & RENAME_NOREPLACE)
4220                 error = -EEXIST;
4221         if (newnd.last_type != LAST_NORM)
4222                 goto exit2;
4223 
4224         error = mnt_want_write(oldnd.path.mnt);
4225         if (error)
4226                 goto exit2;
4227 
4228         oldnd.flags &= ~LOOKUP_PARENT;
4229         newnd.flags &= ~LOOKUP_PARENT;
4230         if (!(flags & RENAME_EXCHANGE))
4231                 newnd.flags |= LOOKUP_RENAME_TARGET;
4232 
4233 retry_deleg:
4234         trap = lock_rename(new_dir, old_dir);
4235 
4236         old_dentry = lookup_hash(&oldnd);
4237         error = PTR_ERR(old_dentry);
4238         if (IS_ERR(old_dentry))
4239                 goto exit3;
4240         /* source must exist */
4241         error = -ENOENT;
4242         if (d_is_negative(old_dentry))
4243                 goto exit4;
4244         new_dentry = lookup_hash(&newnd);
4245         error = PTR_ERR(new_dentry);
4246         if (IS_ERR(new_dentry))
4247                 goto exit4;
4248         error = -EEXIST;
4249         if ((flags & RENAME_NOREPLACE) && d_is_positive(new_dentry))
4250                 goto exit5;
4251         if (flags & RENAME_EXCHANGE) {
4252                 error = -ENOENT;
4253                 if (d_is_negative(new_dentry))
4254                         goto exit5;
4255 
4256                 if (!d_is_dir(new_dentry)) {
4257                         error = -ENOTDIR;
4258                         if (newnd.last.name[newnd.last.len])
4259                                 goto exit5;
4260                 }
4261         }
4262         /* unless the source is a directory trailing slashes give -ENOTDIR */
4263         if (!d_is_dir(old_dentry)) {
4264                 error = -ENOTDIR;
4265                 if (oldnd.last.name[oldnd.last.len])
4266                         goto exit5;
4267                 if (!(flags & RENAME_EXCHANGE) && newnd.last.name[newnd.last.len])
4268                         goto exit5;
4269         }
4270         /* source should not be ancestor of target */
4271         error = -EINVAL;
4272         if (old_dentry == trap)
4273                 goto exit5;
4274         /* target should not be an ancestor of source */
4275         if (!(flags & RENAME_EXCHANGE))
4276                 error = -ENOTEMPTY;
4277         if (new_dentry == trap)
4278                 goto exit5;
4279 
4280         error = security_path_rename(&oldnd.path, old_dentry,
4281                                      &newnd.path, new_dentry, flags);
4282         if (error)
4283                 goto exit5;
4284         error = vfs_rename(old_dir->d_inode, old_dentry,
4285                            new_dir->d_inode, new_dentry,
4286                            &delegated_inode, flags);
4287 exit5:
4288         dput(new_dentry);
4289 exit4:
4290         dput(old_dentry);
4291 exit3:
4292         unlock_rename(new_dir, old_dir);
4293         if (delegated_inode) {
4294                 error = break_deleg_wait(&delegated_inode);
4295                 if (!error)
4296                         goto retry_deleg;
4297         }
4298         mnt_drop_write(oldnd.path.mnt);
4299 exit2:
4300         if (retry_estale(error, lookup_flags))
4301                 should_retry = true;
4302         path_put(&newnd.path);
4303         putname(to);
4304 exit1:
4305         path_put(&oldnd.path);
4306         putname(from);
4307         if (should_retry) {
4308                 should_retry = false;
4309                 lookup_flags |= LOOKUP_REVAL;
4310                 goto retry;
4311         }
4312 exit:
4313         return error;
4314 }
4315 
4316 SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
4317                 int, newdfd, const char __user *, newname)
4318 {
4319         return sys_renameat2(olddfd, oldname, newdfd, newname, 0);
4320 }
4321 
4322 SYSCALL_DEFINE2(rename, const char __user *, oldname, const char __user *, newname)
4323 {
4324         return sys_renameat2(AT_FDCWD, oldname, AT_FDCWD, newname, 0);
4325 }
4326 
4327 int readlink_copy(char __user *buffer, int buflen, const char *link)
4328 {
4329         int len = PTR_ERR(link);
4330         if (IS_ERR(link))
4331                 goto out;
4332 
4333         len = strlen(link);
4334         if (len > (unsigned) buflen)
4335                 len = buflen;
4336         if (copy_to_user(buffer, link, len))
4337                 len = -EFAULT;
4338 out:
4339         return len;
4340 }
4341 EXPORT_SYMBOL(readlink_copy);
4342 
4343 /*
4344  * A helper for ->readlink().  This should be used *ONLY* for symlinks that
4345  * have ->follow_link() touching nd only in nd_set_link().  Using (or not
4346  * using) it for any given inode is up to filesystem.
4347  */
4348 int generic_readlink(struct dentry *dentry, char __user *buffer, int buflen)
4349 {
4350         struct nameidata nd;
4351         void *cookie;
4352         int res;
4353 
4354         nd.depth = 0;
4355         cookie = dentry->d_inode->i_op->follow_link(dentry, &nd);
4356         if (IS_ERR(cookie))
4357                 return PTR_ERR(cookie);
4358 
4359         res = readlink_copy(buffer, buflen, nd_get_link(&nd));
4360         if (dentry->d_inode->i_op->put_link)
4361                 dentry->d_inode->i_op->put_link(dentry, &nd, cookie);
4362         return res;
4363 }
4364 EXPORT_SYMBOL(generic_readlink);
4365 
4366 /* get the link contents into pagecache */
4367 static char *page_getlink(struct dentry * dentry, struct page **ppage)
4368 {
4369         char *kaddr;
4370         struct page *page;
4371         struct address_space *mapping = dentry->d_inode->i_mapping;
4372         page = read_mapping_page(mapping, 0, NULL);
4373         if (IS_ERR(page))
4374                 return (char*)page;
4375         *ppage = page;
4376         kaddr = kmap(page);
4377         nd_terminate_link(kaddr, dentry->d_inode->i_size, PAGE_SIZE - 1);
4378         return kaddr;
4379 }
4380 
4381 int page_readlink(struct dentry *dentry, char __user *buffer, int buflen)
4382 {
4383         struct page *page = NULL;
4384         int res = readlink_copy(buffer, buflen, page_getlink(dentry, &page));
4385         if (page) {
4386                 kunmap(page);
4387                 page_cache_release(page);
4388         }
4389         return res;
4390 }
4391 EXPORT_SYMBOL(page_readlink);
4392 
4393 void *page_follow_link_light(struct dentry *dentry, struct nameidata *nd)
4394 {
4395         struct page *page = NULL;
4396         nd_set_link(nd, page_getlink(dentry, &page));
4397         return page;
4398 }
4399 EXPORT_SYMBOL(page_follow_link_light);
4400 
4401 void page_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
4402 {
4403         struct page *page = cookie;
4404 
4405         if (page) {
4406                 kunmap(page);
4407                 page_cache_release(page);
4408         }
4409 }
4410 EXPORT_SYMBOL(page_put_link);
4411 
4412 /*
4413  * The nofs argument instructs pagecache_write_begin to pass AOP_FLAG_NOFS
4414  */
4415 int __page_symlink(struct inode *inode, const char *symname, int len, int nofs)
4416 {
4417         struct address_space *mapping = inode->i_mapping;
4418         struct page *page;
4419         void *fsdata;
4420         int err;
4421         char *kaddr;
4422         unsigned int flags = AOP_FLAG_UNINTERRUPTIBLE;
4423         if (nofs)
4424                 flags |= AOP_FLAG_NOFS;
4425 
4426 retry:
4427         err = pagecache_write_begin(NULL, mapping, 0, len-1,
4428                                 flags, &page, &fsdata);
4429         if (err)
4430                 goto fail;
4431 
4432         kaddr = kmap_atomic(page);
4433         memcpy(kaddr, symname, len-1);
4434         kunmap_atomic(kaddr);
4435 
4436         err = pagecache_write_end(NULL, mapping, 0, len-1, len-1,
4437                                                         page, fsdata);
4438         if (err < 0)
4439                 goto fail;
4440         if (err < len-1)
4441                 goto retry;
4442 
4443         mark_inode_dirty(inode);
4444         return 0;
4445 fail:
4446         return err;
4447 }
4448 EXPORT_SYMBOL(__page_symlink);
4449 
4450 int page_symlink(struct inode *inode, const char *symname, int len)
4451 {
4452         return __page_symlink(inode, symname, len,
4453                         !(mapping_gfp_mask(inode->i_mapping) & __GFP_FS));
4454 }
4455 EXPORT_SYMBOL(page_symlink);
4456 
4457 const struct inode_operations page_symlink_inode_operations = {
4458         .readlink       = generic_readlink,
4459         .follow_link    = page_follow_link_light,
4460         .put_link       = page_put_link,
4461 };
4462 EXPORT_SYMBOL(page_symlink_inode_operations);
4463 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us