~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/namei.c

Version: ~ [ linux-5.15-rc1 ] ~ [ linux-5.14.5 ] ~ [ linux-5.13.18 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.66 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.147 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.206 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.246 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.282 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.283 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp