1b2441318SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds * linux/fs/namei.c
41da177e4SLinus Torvalds *
51da177e4SLinus Torvalds * Copyright (C) 1991, 1992 Linus Torvalds
61da177e4SLinus Torvalds */
71da177e4SLinus Torvalds
81da177e4SLinus Torvalds /*
91da177e4SLinus Torvalds * Some corrections by tytso.
101da177e4SLinus Torvalds */
111da177e4SLinus Torvalds
121da177e4SLinus Torvalds /* [Feb 1997 T. Schoebel-Theuer] Complete rewrite of the pathname
131da177e4SLinus Torvalds * lookup logic.
141da177e4SLinus Torvalds */
151da177e4SLinus Torvalds /* [Feb-Apr 2000, AV] Rewrite to the new namespace architecture.
161da177e4SLinus Torvalds */
171da177e4SLinus Torvalds
181da177e4SLinus Torvalds #include <linux/init.h>
19630d9c47SPaul Gortmaker #include <linux/export.h>
2044696908SDavid S. Miller #include <linux/kernel.h>
211da177e4SLinus Torvalds #include <linux/slab.h>
221da177e4SLinus Torvalds #include <linux/fs.h>
235970e15dSJeff Layton #include <linux/filelock.h>
241da177e4SLinus Torvalds #include <linux/namei.h>
251da177e4SLinus Torvalds #include <linux/pagemap.h>
262d878178SMatthew Wilcox (Oracle) #include <linux/sched/mm.h>
270eeca283SRobert Love #include <linux/fsnotify.h>
281da177e4SLinus Torvalds #include <linux/personality.h>
291da177e4SLinus Torvalds #include <linux/security.h>
306146f0d5SMimi Zohar #include <linux/ima.h>
311da177e4SLinus Torvalds #include <linux/syscalls.h>
321da177e4SLinus Torvalds #include <linux/mount.h>
331da177e4SLinus Torvalds #include <linux/audit.h>
3416f7e0feSRandy Dunlap #include <linux/capability.h>
35834f2a4aSTrond Myklebust #include <linux/file.h>
365590ff0dSUlrich Drepper #include <linux/fcntl.h>
3708ce5f16SSerge E. Hallyn #include <linux/device_cgroup.h>
385ad4e53bSAl Viro #include <linux/fs_struct.h>
39e77819e5SLinus Torvalds #include <linux/posix_acl.h>
4099d263d4SLinus Torvalds #include <linux/hash.h>
412a18da7aSGeorge Spelvin #include <linux/bitops.h>
42aeaa4a79SEric W. Biederman #include <linux/init_task.h>
437c0f6ba6SLinus Torvalds #include <linux/uaccess.h>
441da177e4SLinus Torvalds
45e81e3f4dSEric Paris #include "internal.h"
46c7105365SAl Viro #include "mount.h"
47e81e3f4dSEric Paris
481da177e4SLinus Torvalds /* [Feb-1997 T. Schoebel-Theuer]
491da177e4SLinus Torvalds * Fundamental changes in the pathname lookup mechanisms (namei)
501da177e4SLinus Torvalds * were necessary because of omirr. The reason is that omirr needs
511da177e4SLinus Torvalds * to know the _real_ pathname, not the user-supplied one, in case
521da177e4SLinus Torvalds * of symlinks (and also when transname replacements occur).
531da177e4SLinus Torvalds *
541da177e4SLinus Torvalds * The new code replaces the old recursive symlink resolution with
551da177e4SLinus Torvalds * an iterative one (in case of non-nested symlink chains). It does
561da177e4SLinus Torvalds * this with calls to <fs>_follow_link().
571da177e4SLinus Torvalds * As a side effect, dir_namei(), _namei() and follow_link() are now
581da177e4SLinus Torvalds * replaced with a single function lookup_dentry() that can handle all
591da177e4SLinus Torvalds * the special cases of the former code.
601da177e4SLinus Torvalds *
611da177e4SLinus Torvalds * With the new dcache, the pathname is stored at each inode, at least as
621da177e4SLinus Torvalds * long as the refcount of the inode is positive. As a side effect, the
631da177e4SLinus Torvalds * size of the dcache depends on the inode cache and thus is dynamic.
641da177e4SLinus Torvalds *
651da177e4SLinus Torvalds * [29-Apr-1998 C. Scott Ananian] Updated above description of symlink
661da177e4SLinus Torvalds * resolution to correspond with current state of the code.
671da177e4SLinus Torvalds *
681da177e4SLinus Torvalds * Note that the symlink resolution is not *completely* iterative.
691da177e4SLinus Torvalds * There is still a significant amount of tail- and mid- recursion in
701da177e4SLinus Torvalds * the algorithm. Also, note that <fs>_readlink() is not used in
711da177e4SLinus Torvalds * lookup_dentry(): lookup_dentry() on the result of <fs>_readlink()
721da177e4SLinus Torvalds * may return different results than <fs>_follow_link(). Many virtual
731da177e4SLinus Torvalds * filesystems (including /proc) exhibit this behavior.
741da177e4SLinus Torvalds */
751da177e4SLinus Torvalds
761da177e4SLinus Torvalds /* [24-Feb-97 T. Schoebel-Theuer] Side effects caused by new implementation:
771da177e4SLinus Torvalds * New symlink semantics: when open() is called with flags O_CREAT | O_EXCL
781da177e4SLinus Torvalds * and the name already exists in form of a symlink, try to create the new
791da177e4SLinus Torvalds * name indicated by the symlink. The old code always complained that the
801da177e4SLinus Torvalds * name already exists, due to not following the symlink even if its target
811da177e4SLinus Torvalds * is nonexistent. The new semantics affects also mknod() and link() when
8225985edcSLucas De Marchi * the name is a symlink pointing to a non-existent name.
831da177e4SLinus Torvalds *
841da177e4SLinus Torvalds * I don't know which semantics is the right one, since I have no access
851da177e4SLinus Torvalds * to standards. But I found by trial that HP-UX 9.0 has the full "new"
861da177e4SLinus Torvalds * semantics implemented, while SunOS 4.1.1 and Solaris (SunOS 5.4) have the
871da177e4SLinus Torvalds * "old" one. Personally, I think the new semantics is much more logical.
881da177e4SLinus Torvalds * Note that "ln old new" where "new" is a symlink pointing to a non-existing
891da177e4SLinus Torvalds * file does succeed in both HP-UX and SunOs, but not in Solaris
901da177e4SLinus Torvalds * and in the old Linux semantics.
911da177e4SLinus Torvalds */
921da177e4SLinus Torvalds
931da177e4SLinus Torvalds /* [16-Dec-97 Kevin Buhr] For security reasons, we change some symlink
941da177e4SLinus Torvalds * semantics. See the comments in "open_namei" and "do_link" below.
951da177e4SLinus Torvalds *
961da177e4SLinus Torvalds * [10-Sep-98 Alan Modra] Another symlink change.
971da177e4SLinus Torvalds */
981da177e4SLinus Torvalds
991da177e4SLinus Torvalds /* [Feb-Apr 2000 AV] Complete rewrite. Rules for symlinks:
1001da177e4SLinus Torvalds * inside the path - always follow.
1011da177e4SLinus Torvalds * in the last component in creation/removal/renaming - never follow.
1021da177e4SLinus Torvalds * if LOOKUP_FOLLOW passed - follow.
1031da177e4SLinus Torvalds * if the pathname has trailing slashes - follow.
1041da177e4SLinus Torvalds * otherwise - don't follow.
1051da177e4SLinus Torvalds * (applied in that order).
1061da177e4SLinus Torvalds *
1071da177e4SLinus Torvalds * [Jun 2000 AV] Inconsistent behaviour of open() in case if flags==O_CREAT
1081da177e4SLinus Torvalds * restored for 2.4. This is the last surviving part of old 4.2BSD bug.
1091da177e4SLinus Torvalds * During the 2.4 we need to fix the userland stuff depending on it -
1101da177e4SLinus Torvalds * hopefully we will be able to get rid of that wart in 2.5. So far only
1111da177e4SLinus Torvalds * XEmacs seems to be relying on it...
1121da177e4SLinus Torvalds */
1131da177e4SLinus Torvalds /*
1141da177e4SLinus Torvalds * [Sep 2001 AV] Single-semaphore locking scheme (kudos to David Holland)
115a11f3a05SArjan van de Ven * implemented. Let's see if raised priority of ->s_vfs_rename_mutex gives
1161da177e4SLinus Torvalds * any extra contention...
1171da177e4SLinus Torvalds */
1181da177e4SLinus Torvalds
1191da177e4SLinus Torvalds /* In order to reduce some races, while at the same time doing additional
1201da177e4SLinus Torvalds * checking and hopefully speeding things up, we copy filenames to the
1211da177e4SLinus Torvalds * kernel data space before using them..
1221da177e4SLinus Torvalds *
1231da177e4SLinus Torvalds * POSIX.1 2.4: an empty pathname is invalid (ENOENT).
1241da177e4SLinus Torvalds * PATH_MAX includes the nul terminator --RR.
1251da177e4SLinus Torvalds */
1267950e385SJeff Layton
127fd2f7cb5SAl Viro #define EMBEDDED_NAME_MAX (PATH_MAX - offsetof(struct filename, iname))
12891a27b2aSJeff Layton
12951f39a1fSDavid Drysdale struct filename *
getname_flags(const char __user * filename,int flags,int * empty)13091a27b2aSJeff Layton getname_flags(const char __user *filename, int flags, int *empty)
13191a27b2aSJeff Layton {
13294b5d262SAl Viro struct filename *result;
1337950e385SJeff Layton char *kname;
13494b5d262SAl Viro int len;
1351da177e4SLinus Torvalds
1367ac86265SJeff Layton result = audit_reusename(filename);
1377ac86265SJeff Layton if (result)
1387ac86265SJeff Layton return result;
1397ac86265SJeff Layton
1407950e385SJeff Layton result = __getname();
1413f9f0aa6SLinus Torvalds if (unlikely(!result))
1424043cde8SEric Paris return ERR_PTR(-ENOMEM);
1431da177e4SLinus Torvalds
1447950e385SJeff Layton /*
1457950e385SJeff Layton * First, try to embed the struct filename inside the names_cache
1467950e385SJeff Layton * allocation
1477950e385SJeff Layton */
148fd2f7cb5SAl Viro kname = (char *)result->iname;
14991a27b2aSJeff Layton result->name = kname;
1507950e385SJeff Layton
15194b5d262SAl Viro len = strncpy_from_user(kname, filename, EMBEDDED_NAME_MAX);
15291a27b2aSJeff Layton if (unlikely(len < 0)) {
15394b5d262SAl Viro __putname(result);
15494b5d262SAl Viro return ERR_PTR(len);
15591a27b2aSJeff Layton }
1563f9f0aa6SLinus Torvalds
1577950e385SJeff Layton /*
1587950e385SJeff Layton * Uh-oh. We have a name that's approaching PATH_MAX. Allocate a
1597950e385SJeff Layton * separate struct filename so we can dedicate the entire
1607950e385SJeff Layton * names_cache allocation for the pathname, and re-do the copy from
1617950e385SJeff Layton * userland.
1627950e385SJeff Layton */
16394b5d262SAl Viro if (unlikely(len == EMBEDDED_NAME_MAX)) {
164fd2f7cb5SAl Viro const size_t size = offsetof(struct filename, iname[1]);
1657950e385SJeff Layton kname = (char *)result;
1667950e385SJeff Layton
167fd2f7cb5SAl Viro /*
168fd2f7cb5SAl Viro * size is chosen that way we to guarantee that
169fd2f7cb5SAl Viro * result->iname[0] is within the same object and that
170fd2f7cb5SAl Viro * kname can't be equal to result->iname, no matter what.
171fd2f7cb5SAl Viro */
172fd2f7cb5SAl Viro result = kzalloc(size, GFP_KERNEL);
17394b5d262SAl Viro if (unlikely(!result)) {
17494b5d262SAl Viro __putname(kname);
17594b5d262SAl Viro return ERR_PTR(-ENOMEM);
1767950e385SJeff Layton }
1777950e385SJeff Layton result->name = kname;
17894b5d262SAl Viro len = strncpy_from_user(kname, filename, PATH_MAX);
17994b5d262SAl Viro if (unlikely(len < 0)) {
18094b5d262SAl Viro __putname(kname);
18194b5d262SAl Viro kfree(result);
18294b5d262SAl Viro return ERR_PTR(len);
18394b5d262SAl Viro }
18494b5d262SAl Viro if (unlikely(len == PATH_MAX)) {
18594b5d262SAl Viro __putname(kname);
18694b5d262SAl Viro kfree(result);
18794b5d262SAl Viro return ERR_PTR(-ENAMETOOLONG);
18894b5d262SAl Viro }
1897950e385SJeff Layton }
1907950e385SJeff Layton
19103adc61eSDan Clash atomic_set(&result->refcnt, 1);
1923f9f0aa6SLinus Torvalds /* The empty path is special. */
1933f9f0aa6SLinus Torvalds if (unlikely(!len)) {
1943f9f0aa6SLinus Torvalds if (empty)
1951fa1e7f6SAndy Whitcroft *empty = 1;
19694b5d262SAl Viro if (!(flags & LOOKUP_EMPTY)) {
19794b5d262SAl Viro putname(result);
19894b5d262SAl Viro return ERR_PTR(-ENOENT);
1991da177e4SLinus Torvalds }
20094b5d262SAl Viro }
2017950e385SJeff Layton
2027950e385SJeff Layton result->uptr = filename;
203c4ad8f98SLinus Torvalds result->aname = NULL;
2041da177e4SLinus Torvalds audit_getname(result);
2051da177e4SLinus Torvalds return result;
2063f9f0aa6SLinus Torvalds }
2073f9f0aa6SLinus Torvalds
20891a27b2aSJeff Layton struct filename *
getname_uflags(const char __user * filename,int uflags)2098228e2c3SDmitry Kadashev getname_uflags(const char __user *filename, int uflags)
2108228e2c3SDmitry Kadashev {
2118228e2c3SDmitry Kadashev int flags = (uflags & AT_EMPTY_PATH) ? LOOKUP_EMPTY : 0;
2128228e2c3SDmitry Kadashev
2138228e2c3SDmitry Kadashev return getname_flags(filename, flags, NULL);
2148228e2c3SDmitry Kadashev }
2158228e2c3SDmitry Kadashev
2168228e2c3SDmitry Kadashev struct filename *
getname(const char __user * filename)21791a27b2aSJeff Layton getname(const char __user * filename)
218f52e0c11SAl Viro {
219f7493e5dSLinus Torvalds return getname_flags(filename, 0, NULL);
220f52e0c11SAl Viro }
221f52e0c11SAl Viro
222c4ad8f98SLinus Torvalds struct filename *
getname_kernel(const char * filename)223c4ad8f98SLinus Torvalds getname_kernel(const char * filename)
224c4ad8f98SLinus Torvalds {
225c4ad8f98SLinus Torvalds struct filename *result;
22608518549SPaul Moore int len = strlen(filename) + 1;
227c4ad8f98SLinus Torvalds
228c4ad8f98SLinus Torvalds result = __getname();
229c4ad8f98SLinus Torvalds if (unlikely(!result))
230c4ad8f98SLinus Torvalds return ERR_PTR(-ENOMEM);
231c4ad8f98SLinus Torvalds
23208518549SPaul Moore if (len <= EMBEDDED_NAME_MAX) {
233fd2f7cb5SAl Viro result->name = (char *)result->iname;
23408518549SPaul Moore } else if (len <= PATH_MAX) {
23530ce4d19SAl Viro const size_t size = offsetof(struct filename, iname[1]);
23608518549SPaul Moore struct filename *tmp;
23708518549SPaul Moore
23830ce4d19SAl Viro tmp = kmalloc(size, GFP_KERNEL);
23908518549SPaul Moore if (unlikely(!tmp)) {
24008518549SPaul Moore __putname(result);
24108518549SPaul Moore return ERR_PTR(-ENOMEM);
24208518549SPaul Moore }
24308518549SPaul Moore tmp->name = (char *)result;
24408518549SPaul Moore result = tmp;
24508518549SPaul Moore } else {
24608518549SPaul Moore __putname(result);
24708518549SPaul Moore return ERR_PTR(-ENAMETOOLONG);
24808518549SPaul Moore }
24908518549SPaul Moore memcpy((char *)result->name, filename, len);
250c4ad8f98SLinus Torvalds result->uptr = NULL;
251c4ad8f98SLinus Torvalds result->aname = NULL;
25203adc61eSDan Clash atomic_set(&result->refcnt, 1);
253fd3522fdSPaul Moore audit_getname(result);
254c4ad8f98SLinus Torvalds
255c4ad8f98SLinus Torvalds return result;
256c4ad8f98SLinus Torvalds }
25774d7970fSNamjae Jeon EXPORT_SYMBOL(getname_kernel);
258c4ad8f98SLinus Torvalds
putname(struct filename * name)25991a27b2aSJeff Layton void putname(struct filename *name)
2601da177e4SLinus Torvalds {
261ea47ab11SAl Viro if (IS_ERR(name))
26291ef658fSDmitry Kadashev return;
26391ef658fSDmitry Kadashev
26403adc61eSDan Clash if (WARN_ON_ONCE(!atomic_read(&name->refcnt)))
26503adc61eSDan Clash return;
26655422d0bSPaul Moore
26703adc61eSDan Clash if (!atomic_dec_and_test(&name->refcnt))
26855422d0bSPaul Moore return;
26955422d0bSPaul Moore
270fd2f7cb5SAl Viro if (name->name != name->iname) {
27155422d0bSPaul Moore __putname(name->name);
27255422d0bSPaul Moore kfree(name);
27355422d0bSPaul Moore } else
27455422d0bSPaul Moore __putname(name);
2751da177e4SLinus Torvalds }
27674d7970fSNamjae Jeon EXPORT_SYMBOL(putname);
2771da177e4SLinus Torvalds
27847291baaSChristian Brauner /**
27947291baaSChristian Brauner * check_acl - perform ACL permission checking
280700b7940SChristian Brauner * @idmap: idmap of the mount the inode was found from
28147291baaSChristian Brauner * @inode: inode to check permissions on
28247291baaSChristian Brauner * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC ...)
28347291baaSChristian Brauner *
28447291baaSChristian Brauner * This function performs the ACL permission checking. Since this function
28547291baaSChristian Brauner * retrieve POSIX acls it needs to know whether it is called from a blocking or
28647291baaSChristian Brauner * non-blocking context and thus cares about the MAY_NOT_BLOCK bit.
28747291baaSChristian Brauner *
288700b7940SChristian Brauner * If the inode has been found through an idmapped mount the idmap of
289700b7940SChristian Brauner * the vfsmount must be passed through @idmap. This function will then take
290700b7940SChristian Brauner * care to map the inode according to @idmap before checking permissions.
29147291baaSChristian Brauner * On non-idmapped mounts or if permission checking is to be performed on the
292700b7940SChristian Brauner * raw inode simply passs @nop_mnt_idmap.
29347291baaSChristian Brauner */
check_acl(struct mnt_idmap * idmap,struct inode * inode,int mask)294700b7940SChristian Brauner static int check_acl(struct mnt_idmap *idmap,
29547291baaSChristian Brauner struct inode *inode, int mask)
296e77819e5SLinus Torvalds {
29784635d68SLinus Torvalds #ifdef CONFIG_FS_POSIX_ACL
298e77819e5SLinus Torvalds struct posix_acl *acl;
299e77819e5SLinus Torvalds
300e77819e5SLinus Torvalds if (mask & MAY_NOT_BLOCK) {
3013567866bSAl Viro acl = get_cached_acl_rcu(inode, ACL_TYPE_ACCESS);
3023567866bSAl Viro if (!acl)
303e77819e5SLinus Torvalds return -EAGAIN;
304cac2f8b8SChristian Brauner /* no ->get_inode_acl() calls in RCU mode... */
305b8a7a3a6SAndreas Gruenbacher if (is_uncached_acl(acl))
306e77819e5SLinus Torvalds return -ECHILD;
307700b7940SChristian Brauner return posix_acl_permission(idmap, inode, acl, mask);
308e77819e5SLinus Torvalds }
309e77819e5SLinus Torvalds
310cac2f8b8SChristian Brauner acl = get_inode_acl(inode, ACL_TYPE_ACCESS);
3114e34e719SChristoph Hellwig if (IS_ERR(acl))
3124e34e719SChristoph Hellwig return PTR_ERR(acl);
313e77819e5SLinus Torvalds if (acl) {
314700b7940SChristian Brauner int error = posix_acl_permission(idmap, inode, acl, mask);
315e77819e5SLinus Torvalds posix_acl_release(acl);
316e77819e5SLinus Torvalds return error;
317e77819e5SLinus Torvalds }
31884635d68SLinus Torvalds #endif
319e77819e5SLinus Torvalds
320e77819e5SLinus Torvalds return -EAGAIN;
321e77819e5SLinus Torvalds }
322e77819e5SLinus Torvalds
32347291baaSChristian Brauner /**
32447291baaSChristian Brauner * acl_permission_check - perform basic UNIX permission checking
325700b7940SChristian Brauner * @idmap: idmap of the mount the inode was found from
32647291baaSChristian Brauner * @inode: inode to check permissions on
32747291baaSChristian Brauner * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC ...)
3285fc475b7SLinus Torvalds *
32947291baaSChristian Brauner * This function performs the basic UNIX permission checking. Since this
33047291baaSChristian Brauner * function may retrieve POSIX acls it needs to know whether it is called from a
33147291baaSChristian Brauner * blocking or non-blocking context and thus cares about the MAY_NOT_BLOCK bit.
33247291baaSChristian Brauner *
333700b7940SChristian Brauner * If the inode has been found through an idmapped mount the idmap of
334700b7940SChristian Brauner * the vfsmount must be passed through @idmap. This function will then take
335700b7940SChristian Brauner * care to map the inode according to @idmap before checking permissions.
33647291baaSChristian Brauner * On non-idmapped mounts or if permission checking is to be performed on the
337700b7940SChristian Brauner * raw inode simply passs @nop_mnt_idmap.
3385909ccaaSLinus Torvalds */
acl_permission_check(struct mnt_idmap * idmap,struct inode * inode,int mask)339700b7940SChristian Brauner static int acl_permission_check(struct mnt_idmap *idmap,
34047291baaSChristian Brauner struct inode *inode, int mask)
3415909ccaaSLinus Torvalds {
34226cf46beSLinus Torvalds unsigned int mode = inode->i_mode;
343a2bd096fSChristian Brauner vfsuid_t vfsuid;
3445909ccaaSLinus Torvalds
3455fc475b7SLinus Torvalds /* Are we the owner? If so, ACL's don't matter */
346e67fe633SChristian Brauner vfsuid = i_uid_into_vfsuid(idmap, inode);
347a2bd096fSChristian Brauner if (likely(vfsuid_eq_kuid(vfsuid, current_fsuid()))) {
3485fc475b7SLinus Torvalds mask &= 7;
3495909ccaaSLinus Torvalds mode >>= 6;
3505fc475b7SLinus Torvalds return (mask & ~mode) ? -EACCES : 0;
3515fc475b7SLinus Torvalds }
3525fc475b7SLinus Torvalds
3535fc475b7SLinus Torvalds /* Do we have ACL's? */
354e77819e5SLinus Torvalds if (IS_POSIXACL(inode) && (mode & S_IRWXG)) {
355700b7940SChristian Brauner int error = check_acl(idmap, inode, mask);
3565909ccaaSLinus Torvalds if (error != -EAGAIN)
3575909ccaaSLinus Torvalds return error;
3585909ccaaSLinus Torvalds }
3595909ccaaSLinus Torvalds
3605fc475b7SLinus Torvalds /* Only RWX matters for group/other mode bits */
3615fc475b7SLinus Torvalds mask &= 7;
3625fc475b7SLinus Torvalds
3635fc475b7SLinus Torvalds /*
3645fc475b7SLinus Torvalds * Are the group permissions different from
3655fc475b7SLinus Torvalds * the other permissions in the bits we care
3665fc475b7SLinus Torvalds * about? Need to check group ownership if so.
3675fc475b7SLinus Torvalds */
3685fc475b7SLinus Torvalds if (mask & (mode ^ (mode >> 3))) {
369e67fe633SChristian Brauner vfsgid_t vfsgid = i_gid_into_vfsgid(idmap, inode);
370a2bd096fSChristian Brauner if (vfsgid_in_group_p(vfsgid))
3715909ccaaSLinus Torvalds mode >>= 3;
3725909ccaaSLinus Torvalds }
3735909ccaaSLinus Torvalds
3745fc475b7SLinus Torvalds /* Bits in 'mode' clear that we require? */
3755fc475b7SLinus Torvalds return (mask & ~mode) ? -EACCES : 0;
3765909ccaaSLinus Torvalds }
3771da177e4SLinus Torvalds
3781da177e4SLinus Torvalds /**
3791da177e4SLinus Torvalds * generic_permission - check for access rights on a Posix-like filesystem
3804609e1f1SChristian Brauner * @idmap: idmap of the mount the inode was found from
3811da177e4SLinus Torvalds * @inode: inode to check access rights for
3825fc475b7SLinus Torvalds * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC,
3835fc475b7SLinus Torvalds * %MAY_NOT_BLOCK ...)
3841da177e4SLinus Torvalds *
3851da177e4SLinus Torvalds * Used to check for read/write/execute permissions on a file.
3861da177e4SLinus Torvalds * We use "fsuid" for this, letting us set arbitrary permissions
3871da177e4SLinus Torvalds * for filesystem access without changing the "normal" uids which
388b74c79e9SNick Piggin * are used for other things.
389b74c79e9SNick Piggin *
390b74c79e9SNick Piggin * generic_permission is rcu-walk aware. It returns -ECHILD in case an rcu-walk
391b74c79e9SNick Piggin * request cannot be satisfied (eg. requires blocking or too much complexity).
392b74c79e9SNick Piggin * It would then be called again in ref-walk mode.
39347291baaSChristian Brauner *
3944609e1f1SChristian Brauner * If the inode has been found through an idmapped mount the idmap of
3954609e1f1SChristian Brauner * the vfsmount must be passed through @idmap. This function will then take
3964609e1f1SChristian Brauner * care to map the inode according to @idmap before checking permissions.
39747291baaSChristian Brauner * On non-idmapped mounts or if permission checking is to be performed on the
3984609e1f1SChristian Brauner * raw inode simply passs @nop_mnt_idmap.
3991da177e4SLinus Torvalds */
generic_permission(struct mnt_idmap * idmap,struct inode * inode,int mask)4004609e1f1SChristian Brauner int generic_permission(struct mnt_idmap *idmap, struct inode *inode,
40147291baaSChristian Brauner int mask)
4021da177e4SLinus Torvalds {
4035909ccaaSLinus Torvalds int ret;
4041da177e4SLinus Torvalds
4051da177e4SLinus Torvalds /*
406948409c7SAndreas Gruenbacher * Do the basic permission checks.
4071da177e4SLinus Torvalds */
408700b7940SChristian Brauner ret = acl_permission_check(idmap, inode, mask);
4095909ccaaSLinus Torvalds if (ret != -EACCES)
4105909ccaaSLinus Torvalds return ret;
4111da177e4SLinus Torvalds
412d594e7ecSAl Viro if (S_ISDIR(inode->i_mode)) {
413d594e7ecSAl Viro /* DACs are overridable for directories */
414d594e7ecSAl Viro if (!(mask & MAY_WRITE))
4159452e93eSChristian Brauner if (capable_wrt_inode_uidgid(idmap, inode,
41623adbe12SAndy Lutomirski CAP_DAC_READ_SEARCH))
417d594e7ecSAl Viro return 0;
4189452e93eSChristian Brauner if (capable_wrt_inode_uidgid(idmap, inode,
4190558c1bfSChristian Brauner CAP_DAC_OVERRIDE))
4201da177e4SLinus Torvalds return 0;
4212a4c2242SStephen Smalley return -EACCES;
4222a4c2242SStephen Smalley }
4231da177e4SLinus Torvalds
4241da177e4SLinus Torvalds /*
4251da177e4SLinus Torvalds * Searching includes executable on directories, else just read.
4261da177e4SLinus Torvalds */
4277ea66001SSerge E. Hallyn mask &= MAY_READ | MAY_WRITE | MAY_EXEC;
428d594e7ecSAl Viro if (mask == MAY_READ)
4299452e93eSChristian Brauner if (capable_wrt_inode_uidgid(idmap, inode,
4300558c1bfSChristian Brauner CAP_DAC_READ_SEARCH))
4311da177e4SLinus Torvalds return 0;
4322a4c2242SStephen Smalley /*
4332a4c2242SStephen Smalley * Read/write DACs are always overridable.
4342a4c2242SStephen Smalley * Executable DACs are overridable when there is
4352a4c2242SStephen Smalley * at least one exec bit set.
4362a4c2242SStephen Smalley */
4372a4c2242SStephen Smalley if (!(mask & MAY_EXEC) || (inode->i_mode & S_IXUGO))
4389452e93eSChristian Brauner if (capable_wrt_inode_uidgid(idmap, inode,
4390558c1bfSChristian Brauner CAP_DAC_OVERRIDE))
4402a4c2242SStephen Smalley return 0;
4411da177e4SLinus Torvalds
4421da177e4SLinus Torvalds return -EACCES;
4431da177e4SLinus Torvalds }
4444d359507SAl Viro EXPORT_SYMBOL(generic_permission);
4451da177e4SLinus Torvalds
44647291baaSChristian Brauner /**
44747291baaSChristian Brauner * do_inode_permission - UNIX permission checking
4484609e1f1SChristian Brauner * @idmap: idmap of the mount the inode was found from
44947291baaSChristian Brauner * @inode: inode to check permissions on
45047291baaSChristian Brauner * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC ...)
45147291baaSChristian Brauner *
4523ddcd056SLinus Torvalds * We _really_ want to just do "generic_permission()" without
4533ddcd056SLinus Torvalds * even looking at the inode->i_op values. So we keep a cache
4543ddcd056SLinus Torvalds * flag in inode->i_opflags, that says "this has not special
4553ddcd056SLinus Torvalds * permission function, use the fast case".
4563ddcd056SLinus Torvalds */
do_inode_permission(struct mnt_idmap * idmap,struct inode * inode,int mask)4574609e1f1SChristian Brauner static inline int do_inode_permission(struct mnt_idmap *idmap,
45847291baaSChristian Brauner struct inode *inode, int mask)
4593ddcd056SLinus Torvalds {
4603ddcd056SLinus Torvalds if (unlikely(!(inode->i_opflags & IOP_FASTPERM))) {
4613ddcd056SLinus Torvalds if (likely(inode->i_op->permission))
4624609e1f1SChristian Brauner return inode->i_op->permission(idmap, inode, mask);
4633ddcd056SLinus Torvalds
4643ddcd056SLinus Torvalds /* This gets set once for the inode lifetime */
4653ddcd056SLinus Torvalds spin_lock(&inode->i_lock);
4663ddcd056SLinus Torvalds inode->i_opflags |= IOP_FASTPERM;
4673ddcd056SLinus Torvalds spin_unlock(&inode->i_lock);
4683ddcd056SLinus Torvalds }
4694609e1f1SChristian Brauner return generic_permission(idmap, inode, mask);
4703ddcd056SLinus Torvalds }
4713ddcd056SLinus Torvalds
472cb23beb5SChristoph Hellwig /**
4730bdaea90SDavid Howells * sb_permission - Check superblock-level permissions
4740bdaea90SDavid Howells * @sb: Superblock of inode to check permission on
47555852635SRandy Dunlap * @inode: Inode to check permission on
4760bdaea90SDavid Howells * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
4770bdaea90SDavid Howells *
4780bdaea90SDavid Howells * Separate out file-system wide checks from inode-specific permission checks.
4790bdaea90SDavid Howells */
sb_permission(struct super_block * sb,struct inode * inode,int mask)4800bdaea90SDavid Howells static int sb_permission(struct super_block *sb, struct inode *inode, int mask)
4810bdaea90SDavid Howells {
4820bdaea90SDavid Howells if (unlikely(mask & MAY_WRITE)) {
4830bdaea90SDavid Howells umode_t mode = inode->i_mode;
4840bdaea90SDavid Howells
4850bdaea90SDavid Howells /* Nobody gets write access to a read-only fs. */
486bc98a42cSDavid Howells if (sb_rdonly(sb) && (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
4870bdaea90SDavid Howells return -EROFS;
4880bdaea90SDavid Howells }
4890bdaea90SDavid Howells return 0;
4900bdaea90SDavid Howells }
4910bdaea90SDavid Howells
4920bdaea90SDavid Howells /**
4930bdaea90SDavid Howells * inode_permission - Check for access rights to a given inode
4944609e1f1SChristian Brauner * @idmap: idmap of the mount the inode was found from
4950bdaea90SDavid Howells * @inode: Inode to check permission on
4960bdaea90SDavid Howells * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
4970bdaea90SDavid Howells *
4980bdaea90SDavid Howells * Check for read/write/execute permissions on an inode. We use fs[ug]id for
4990bdaea90SDavid Howells * this, letting us set arbitrary permissions for filesystem access without
5000bdaea90SDavid Howells * changing the "normal" UIDs which are used for other things.
5010bdaea90SDavid Howells *
5020bdaea90SDavid Howells * When checking for MAY_APPEND, MAY_WRITE must also be set in @mask.
5030bdaea90SDavid Howells */
inode_permission(struct mnt_idmap * idmap,struct inode * inode,int mask)5044609e1f1SChristian Brauner int inode_permission(struct mnt_idmap *idmap,
50547291baaSChristian Brauner struct inode *inode, int mask)
5060bdaea90SDavid Howells {
5070bdaea90SDavid Howells int retval;
5080bdaea90SDavid Howells
5090bdaea90SDavid Howells retval = sb_permission(inode->i_sb, inode, mask);
5100bdaea90SDavid Howells if (retval)
5110bdaea90SDavid Howells return retval;
5124bfd054aSEric Biggers
5134bfd054aSEric Biggers if (unlikely(mask & MAY_WRITE)) {
5144bfd054aSEric Biggers /*
5154bfd054aSEric Biggers * Nobody gets write access to an immutable file.
5164bfd054aSEric Biggers */
5174bfd054aSEric Biggers if (IS_IMMUTABLE(inode))
5184bfd054aSEric Biggers return -EPERM;
5194bfd054aSEric Biggers
5204bfd054aSEric Biggers /*
5214bfd054aSEric Biggers * Updating mtime will likely cause i_uid and i_gid to be
5224bfd054aSEric Biggers * written back improperly if their true value is unknown
5234bfd054aSEric Biggers * to the vfs.
5244bfd054aSEric Biggers */
5254609e1f1SChristian Brauner if (HAS_UNMAPPED_ID(idmap, inode))
5264bfd054aSEric Biggers return -EACCES;
5274bfd054aSEric Biggers }
5284bfd054aSEric Biggers
5294609e1f1SChristian Brauner retval = do_inode_permission(idmap, inode, mask);
5304bfd054aSEric Biggers if (retval)
5314bfd054aSEric Biggers return retval;
5324bfd054aSEric Biggers
5334bfd054aSEric Biggers retval = devcgroup_inode_permission(inode, mask);
5344bfd054aSEric Biggers if (retval)
5354bfd054aSEric Biggers return retval;
5364bfd054aSEric Biggers
5374bfd054aSEric Biggers return security_inode_permission(inode, mask);
5380bdaea90SDavid Howells }
5394d359507SAl Viro EXPORT_SYMBOL(inode_permission);
5400bdaea90SDavid Howells
5410bdaea90SDavid Howells /**
5425dd784d0SJan Blunck * path_get - get a reference to a path
5435dd784d0SJan Blunck * @path: path to get the reference to
5445dd784d0SJan Blunck *
5455dd784d0SJan Blunck * Given a path increment the reference count to the dentry and the vfsmount.
5465dd784d0SJan Blunck */
path_get(const struct path * path)547dcf787f3SAl Viro void path_get(const struct path *path)
5485dd784d0SJan Blunck {
5495dd784d0SJan Blunck mntget(path->mnt);
5505dd784d0SJan Blunck dget(path->dentry);
5515dd784d0SJan Blunck }
5525dd784d0SJan Blunck EXPORT_SYMBOL(path_get);
5535dd784d0SJan Blunck
5545dd784d0SJan Blunck /**
5551d957f9bSJan Blunck * path_put - put a reference to a path
5561d957f9bSJan Blunck * @path: path to put the reference to
5571d957f9bSJan Blunck *
5581d957f9bSJan Blunck * Given a path decrement the reference count to the dentry and the vfsmount.
5591d957f9bSJan Blunck */
path_put(const struct path * path)560dcf787f3SAl Viro void path_put(const struct path *path)
5611da177e4SLinus Torvalds {
5621d957f9bSJan Blunck dput(path->dentry);
5631d957f9bSJan Blunck mntput(path->mnt);
5641da177e4SLinus Torvalds }
5651d957f9bSJan Blunck EXPORT_SYMBOL(path_put);
5661da177e4SLinus Torvalds
567894bc8c4SAl Viro #define EMBEDDED_LEVELS 2
5681f55a6ecSAl Viro struct nameidata {
5691f55a6ecSAl Viro struct path path;
5701f55a6ecSAl Viro struct qstr last;
5711f55a6ecSAl Viro struct path root;
5721f55a6ecSAl Viro struct inode *inode; /* path.dentry.d_inode */
573bcba1e7dSAl Viro unsigned int flags, state;
57403fa86e9SAl Viro unsigned seq, next_seq, m_seq, r_seq;
5751f55a6ecSAl Viro int last_type;
5761f55a6ecSAl Viro unsigned depth;
577756daf26SNeilBrown int total_link_count;
578697fc6caSAl Viro struct saved {
579697fc6caSAl Viro struct path link;
580fceef393SAl Viro struct delayed_call done;
581697fc6caSAl Viro const char *name;
5820450b2d1SAl Viro unsigned seq;
583894bc8c4SAl Viro } *stack, internal[EMBEDDED_LEVELS];
5849883d185SAl Viro struct filename *name;
5859883d185SAl Viro struct nameidata *saved;
5869883d185SAl Viro unsigned root_seq;
5879883d185SAl Viro int dfd;
588a2bd096fSChristian Brauner vfsuid_t dir_vfsuid;
5890f705953SAl Viro umode_t dir_mode;
5903859a271SKees Cook } __randomize_layout;
5911f55a6ecSAl Viro
592bcba1e7dSAl Viro #define ND_ROOT_PRESET 1
593bcba1e7dSAl Viro #define ND_ROOT_GRABBED 2
594bcba1e7dSAl Viro #define ND_JUMPED 4
595bcba1e7dSAl Viro
__set_nameidata(struct nameidata * p,int dfd,struct filename * name)59606422964SAl Viro static void __set_nameidata(struct nameidata *p, int dfd, struct filename *name)
597894bc8c4SAl Viro {
598756daf26SNeilBrown struct nameidata *old = current->nameidata;
599756daf26SNeilBrown p->stack = p->internal;
6007962c7d1SAl Viro p->depth = 0;
601c8a53ee5SAl Viro p->dfd = dfd;
602c8a53ee5SAl Viro p->name = name;
6037d01ef75SAl Viro p->path.mnt = NULL;
6047d01ef75SAl Viro p->path.dentry = NULL;
605756daf26SNeilBrown p->total_link_count = old ? old->total_link_count : 0;
6069883d185SAl Viro p->saved = old;
607756daf26SNeilBrown current->nameidata = p;
608894bc8c4SAl Viro }
609894bc8c4SAl Viro
set_nameidata(struct nameidata * p,int dfd,struct filename * name,const struct path * root)61006422964SAl Viro static inline void set_nameidata(struct nameidata *p, int dfd, struct filename *name,
61106422964SAl Viro const struct path *root)
61206422964SAl Viro {
61306422964SAl Viro __set_nameidata(p, dfd, name);
61406422964SAl Viro p->state = 0;
61506422964SAl Viro if (unlikely(root)) {
61606422964SAl Viro p->state = ND_ROOT_PRESET;
61706422964SAl Viro p->root = *root;
61806422964SAl Viro }
61906422964SAl Viro }
62006422964SAl Viro
restore_nameidata(void)6219883d185SAl Viro static void restore_nameidata(void)
622894bc8c4SAl Viro {
6239883d185SAl Viro struct nameidata *now = current->nameidata, *old = now->saved;
624756daf26SNeilBrown
625756daf26SNeilBrown current->nameidata = old;
626756daf26SNeilBrown if (old)
627756daf26SNeilBrown old->total_link_count = now->total_link_count;
628e1a63bbcSAl Viro if (now->stack != now->internal)
629756daf26SNeilBrown kfree(now->stack);
630894bc8c4SAl Viro }
631894bc8c4SAl Viro
nd_alloc_stack(struct nameidata * nd)63260ef60c7SAl Viro static bool nd_alloc_stack(struct nameidata *nd)
633894bc8c4SAl Viro {
634bc40aee0SAl Viro struct saved *p;
635bc40aee0SAl Viro
6366da2ec56SKees Cook p= kmalloc_array(MAXSYMLINKS, sizeof(struct saved),
63760ef60c7SAl Viro nd->flags & LOOKUP_RCU ? GFP_ATOMIC : GFP_KERNEL);
638bc40aee0SAl Viro if (unlikely(!p))
63960ef60c7SAl Viro return false;
640894bc8c4SAl Viro memcpy(p, nd->internal, sizeof(nd->internal));
641894bc8c4SAl Viro nd->stack = p;
64260ef60c7SAl Viro return true;
643894bc8c4SAl Viro }
644894bc8c4SAl Viro
645397d425dSEric W. Biederman /**
6466b03f7edSAl Viro * path_connected - Verify that a dentry is below mnt.mnt_root
64735931eb3SMatthew Wilcox (Oracle) * @mnt: The mountpoint to check.
64835931eb3SMatthew Wilcox (Oracle) * @dentry: The dentry to check.
649397d425dSEric W. Biederman *
650397d425dSEric W. Biederman * Rename can sometimes move a file or directory outside of a bind
651397d425dSEric W. Biederman * mount, path_connected allows those cases to be detected.
652397d425dSEric W. Biederman */
path_connected(struct vfsmount * mnt,struct dentry * dentry)6536b03f7edSAl Viro static bool path_connected(struct vfsmount *mnt, struct dentry *dentry)
654397d425dSEric W. Biederman {
65595dd7758SEric W. Biederman struct super_block *sb = mnt->mnt_sb;
656397d425dSEric W. Biederman
657402dd2cfSChristoph Hellwig /* Bind mounts can have disconnected paths */
658402dd2cfSChristoph Hellwig if (mnt->mnt_root == sb->s_root)
659397d425dSEric W. Biederman return true;
660397d425dSEric W. Biederman
6616b03f7edSAl Viro return is_subdir(dentry, mnt->mnt_root);
662397d425dSEric W. Biederman }
663397d425dSEric W. Biederman
drop_links(struct nameidata * nd)6647973387aSAl Viro static void drop_links(struct nameidata *nd)
6657973387aSAl Viro {
6667973387aSAl Viro int i = nd->depth;
6677973387aSAl Viro while (i--) {
6687973387aSAl Viro struct saved *last = nd->stack + i;
669fceef393SAl Viro do_delayed_call(&last->done);
670fceef393SAl Viro clear_delayed_call(&last->done);
6717973387aSAl Viro }
6727973387aSAl Viro }
6737973387aSAl Viro
leave_rcu(struct nameidata * nd)6746e180327SAl Viro static void leave_rcu(struct nameidata *nd)
6756e180327SAl Viro {
6766e180327SAl Viro nd->flags &= ~LOOKUP_RCU;
67703fa86e9SAl Viro nd->seq = nd->next_seq = 0;
6786e180327SAl Viro rcu_read_unlock();
6796e180327SAl Viro }
6806e180327SAl Viro
terminate_walk(struct nameidata * nd)6817973387aSAl Viro static void terminate_walk(struct nameidata *nd)
6827973387aSAl Viro {
6837973387aSAl Viro drop_links(nd);
6847973387aSAl Viro if (!(nd->flags & LOOKUP_RCU)) {
6857973387aSAl Viro int i;
6867973387aSAl Viro path_put(&nd->path);
6877973387aSAl Viro for (i = 0; i < nd->depth; i++)
6887973387aSAl Viro path_put(&nd->stack[i].link);
689bcba1e7dSAl Viro if (nd->state & ND_ROOT_GRABBED) {
690102b8af2SAl Viro path_put(&nd->root);
691bcba1e7dSAl Viro nd->state &= ~ND_ROOT_GRABBED;
692102b8af2SAl Viro }
6937973387aSAl Viro } else {
6946e180327SAl Viro leave_rcu(nd);
6957973387aSAl Viro }
6967973387aSAl Viro nd->depth = 0;
6977d01ef75SAl Viro nd->path.mnt = NULL;
6987d01ef75SAl Viro nd->path.dentry = NULL;
6997973387aSAl Viro }
7007973387aSAl Viro
7017973387aSAl Viro /* path_put is needed afterwards regardless of success or failure */
__legitimize_path(struct path * path,unsigned seq,unsigned mseq)7022aa38470SAl Viro static bool __legitimize_path(struct path *path, unsigned seq, unsigned mseq)
7037973387aSAl Viro {
7042aa38470SAl Viro int res = __legitimize_mnt(path->mnt, mseq);
7057973387aSAl Viro if (unlikely(res)) {
7067973387aSAl Viro if (res > 0)
7077973387aSAl Viro path->mnt = NULL;
7087973387aSAl Viro path->dentry = NULL;
7097973387aSAl Viro return false;
7107973387aSAl Viro }
7117973387aSAl Viro if (unlikely(!lockref_get_not_dead(&path->dentry->d_lockref))) {
7127973387aSAl Viro path->dentry = NULL;
7137973387aSAl Viro return false;
7147973387aSAl Viro }
7157973387aSAl Viro return !read_seqcount_retry(&path->dentry->d_seq, seq);
7167973387aSAl Viro }
7177973387aSAl Viro
legitimize_path(struct nameidata * nd,struct path * path,unsigned seq)7182aa38470SAl Viro static inline bool legitimize_path(struct nameidata *nd,
7192aa38470SAl Viro struct path *path, unsigned seq)
7202aa38470SAl Viro {
7215bd73286SAl Viro return __legitimize_path(path, seq, nd->m_seq);
7222aa38470SAl Viro }
7232aa38470SAl Viro
legitimize_links(struct nameidata * nd)7247973387aSAl Viro static bool legitimize_links(struct nameidata *nd)
7257973387aSAl Viro {
7267973387aSAl Viro int i;
727eacd9aa8SAl Viro if (unlikely(nd->flags & LOOKUP_CACHED)) {
728eacd9aa8SAl Viro drop_links(nd);
729eacd9aa8SAl Viro nd->depth = 0;
730eacd9aa8SAl Viro return false;
731eacd9aa8SAl Viro }
7327973387aSAl Viro for (i = 0; i < nd->depth; i++) {
7337973387aSAl Viro struct saved *last = nd->stack + i;
7347973387aSAl Viro if (unlikely(!legitimize_path(nd, &last->link, last->seq))) {
7357973387aSAl Viro drop_links(nd);
7367973387aSAl Viro nd->depth = i + 1;
7377973387aSAl Viro return false;
7387973387aSAl Viro }
7397973387aSAl Viro }
7407973387aSAl Viro return true;
7417973387aSAl Viro }
7427973387aSAl Viro
legitimize_root(struct nameidata * nd)743ee594bffSAl Viro static bool legitimize_root(struct nameidata *nd)
744ee594bffSAl Viro {
745adb21d2bSAleksa Sarai /* Nothing to do if nd->root is zero or is managed by the VFS user. */
746bcba1e7dSAl Viro if (!nd->root.mnt || (nd->state & ND_ROOT_PRESET))
747ee594bffSAl Viro return true;
748bcba1e7dSAl Viro nd->state |= ND_ROOT_GRABBED;
749ee594bffSAl Viro return legitimize_path(nd, &nd->root, nd->root_seq);
750ee594bffSAl Viro }
751ee594bffSAl Viro
75219660af7SAl Viro /*
75331e6b01fSNick Piggin * Path walking has 2 modes, rcu-walk and ref-walk (see
75419660af7SAl Viro * Documentation/filesystems/path-lookup.txt). In situations when we can't
75519660af7SAl Viro * continue in RCU mode, we attempt to drop out of rcu-walk mode and grab
75657e3715cSMike Marshall * normal reference counts on dentries and vfsmounts to transition to ref-walk
75719660af7SAl Viro * mode. Refcounts are grabbed at the last known good point before rcu-walk
75819660af7SAl Viro * got stuck, so ref-walk may continue from there. If this is not successful
75919660af7SAl Viro * (eg. a seqcount has changed), then failure is returned and it's up to caller
76019660af7SAl Viro * to restart the path walk from the beginning in ref-walk mode.
76131e6b01fSNick Piggin */
76231e6b01fSNick Piggin
76331e6b01fSNick Piggin /**
764e36cffedSJens Axboe * try_to_unlazy - try to switch to ref-walk mode.
76519660af7SAl Viro * @nd: nameidata pathwalk data
766e36cffedSJens Axboe * Returns: true on success, false on failure
76731e6b01fSNick Piggin *
768e36cffedSJens Axboe * try_to_unlazy attempts to legitimize the current nd->path and nd->root
7694675ac39SAl Viro * for ref-walk mode.
7704675ac39SAl Viro * Must be called from rcu-walk context.
771e36cffedSJens Axboe * Nothing should touch nameidata between try_to_unlazy() failure and
7727973387aSAl Viro * terminate_walk().
77331e6b01fSNick Piggin */
try_to_unlazy(struct nameidata * nd)774e36cffedSJens Axboe static bool try_to_unlazy(struct nameidata *nd)
77531e6b01fSNick Piggin {
77631e6b01fSNick Piggin struct dentry *parent = nd->path.dentry;
77731e6b01fSNick Piggin
77831e6b01fSNick Piggin BUG_ON(!(nd->flags & LOOKUP_RCU));
779e5c832d5SLinus Torvalds
7807973387aSAl Viro if (unlikely(!legitimize_links(nd)))
7814675ac39SAl Viro goto out1;
78284a2bd39SAl Viro if (unlikely(!legitimize_path(nd, &nd->path, nd->seq)))
78384a2bd39SAl Viro goto out;
784ee594bffSAl Viro if (unlikely(!legitimize_root(nd)))
7854675ac39SAl Viro goto out;
7866e180327SAl Viro leave_rcu(nd);
7874675ac39SAl Viro BUG_ON(nd->inode != parent->d_inode);
788e36cffedSJens Axboe return true;
7894675ac39SAl Viro
79084a2bd39SAl Viro out1:
7914675ac39SAl Viro nd->path.mnt = NULL;
7924675ac39SAl Viro nd->path.dentry = NULL;
7934675ac39SAl Viro out:
7946e180327SAl Viro leave_rcu(nd);
795e36cffedSJens Axboe return false;
7964675ac39SAl Viro }
7974675ac39SAl Viro
7984675ac39SAl Viro /**
799ae66db45SAl Viro * try_to_unlazy_next - try to switch to ref-walk mode.
8004675ac39SAl Viro * @nd: nameidata pathwalk data
801ae66db45SAl Viro * @dentry: next dentry to step into
802ae66db45SAl Viro * Returns: true on success, false on failure
8034675ac39SAl Viro *
80430476f7eSTom Rix * Similar to try_to_unlazy(), but here we have the next dentry already
805ae66db45SAl Viro * picked by rcu-walk and want to legitimize that in addition to the current
806ae66db45SAl Viro * nd->path and nd->root for ref-walk mode. Must be called from rcu-walk context.
807ae66db45SAl Viro * Nothing should touch nameidata between try_to_unlazy_next() failure and
8084675ac39SAl Viro * terminate_walk().
8094675ac39SAl Viro */
try_to_unlazy_next(struct nameidata * nd,struct dentry * dentry)81003fa86e9SAl Viro static bool try_to_unlazy_next(struct nameidata *nd, struct dentry *dentry)
8114675ac39SAl Viro {
8127e4745a0SAl Viro int res;
8134675ac39SAl Viro BUG_ON(!(nd->flags & LOOKUP_RCU));
8144675ac39SAl Viro
8154675ac39SAl Viro if (unlikely(!legitimize_links(nd)))
8164675ac39SAl Viro goto out2;
8177e4745a0SAl Viro res = __legitimize_mnt(nd->path.mnt, nd->m_seq);
8187e4745a0SAl Viro if (unlikely(res)) {
8197e4745a0SAl Viro if (res > 0)
8207973387aSAl Viro goto out2;
8217e4745a0SAl Viro goto out1;
8227e4745a0SAl Viro }
8234675ac39SAl Viro if (unlikely(!lockref_get_not_dead(&nd->path.dentry->d_lockref)))
8247973387aSAl Viro goto out1;
82548a066e7SAl Viro
82615570086SLinus Torvalds /*
8274675ac39SAl Viro * We need to move both the parent and the dentry from the RCU domain
8284675ac39SAl Viro * to be properly refcounted. And the sequence number in the dentry
8294675ac39SAl Viro * validates *both* dentry counters, since we checked the sequence
8304675ac39SAl Viro * number of the parent after we got the child sequence number. So we
8314675ac39SAl Viro * know the parent must still be valid if the child sequence number is
83215570086SLinus Torvalds */
8334675ac39SAl Viro if (unlikely(!lockref_get_not_dead(&dentry->d_lockref)))
834e5c832d5SLinus Torvalds goto out;
83503fa86e9SAl Viro if (read_seqcount_retry(&dentry->d_seq, nd->next_seq))
83684a2bd39SAl Viro goto out_dput;
837e5c832d5SLinus Torvalds /*
838e5c832d5SLinus Torvalds * Sequence counts matched. Now make sure that the root is
839e5c832d5SLinus Torvalds * still valid and get it if required.
840e5c832d5SLinus Torvalds */
84184a2bd39SAl Viro if (unlikely(!legitimize_root(nd)))
84284a2bd39SAl Viro goto out_dput;
8436e180327SAl Viro leave_rcu(nd);
844ae66db45SAl Viro return true;
84519660af7SAl Viro
8467973387aSAl Viro out2:
8477973387aSAl Viro nd->path.mnt = NULL;
8487973387aSAl Viro out1:
8497973387aSAl Viro nd->path.dentry = NULL;
850e5c832d5SLinus Torvalds out:
8516e180327SAl Viro leave_rcu(nd);
852ae66db45SAl Viro return false;
85384a2bd39SAl Viro out_dput:
8546e180327SAl Viro leave_rcu(nd);
85584a2bd39SAl Viro dput(dentry);
856ae66db45SAl Viro return false;
85731e6b01fSNick Piggin }
85831e6b01fSNick Piggin
d_revalidate(struct dentry * dentry,unsigned int flags)8594ce16ef3SAl Viro static inline int d_revalidate(struct dentry *dentry, unsigned int flags)
86034286d66SNick Piggin {
861a89f8337SAl Viro if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE))
8624ce16ef3SAl Viro return dentry->d_op->d_revalidate(dentry, flags);
863a89f8337SAl Viro else
864a89f8337SAl Viro return 1;
86534286d66SNick Piggin }
86634286d66SNick Piggin
8679f1fafeeSAl Viro /**
8689f1fafeeSAl Viro * complete_walk - successful completion of path walk
8699f1fafeeSAl Viro * @nd: pointer nameidata
87039159de2SJeff Layton *
8719f1fafeeSAl Viro * If we had been in RCU mode, drop out of it and legitimize nd->path.
8729f1fafeeSAl Viro * Revalidate the final result, unless we'd already done that during
8739f1fafeeSAl Viro * the path walk or the filesystem doesn't ask for it. Return 0 on
8749f1fafeeSAl Viro * success, -error on failure. In case of failure caller does not
8759f1fafeeSAl Viro * need to drop nd->path.
87639159de2SJeff Layton */
complete_walk(struct nameidata * nd)8779f1fafeeSAl Viro static int complete_walk(struct nameidata *nd)
87839159de2SJeff Layton {
87916c2cd71SAl Viro struct dentry *dentry = nd->path.dentry;
88039159de2SJeff Layton int status;
88139159de2SJeff Layton
8829f1fafeeSAl Viro if (nd->flags & LOOKUP_RCU) {
883adb21d2bSAleksa Sarai /*
884adb21d2bSAleksa Sarai * We don't want to zero nd->root for scoped-lookups or
885adb21d2bSAleksa Sarai * externally-managed nd->root.
886adb21d2bSAleksa Sarai */
887bcba1e7dSAl Viro if (!(nd->state & ND_ROOT_PRESET))
888bcba1e7dSAl Viro if (!(nd->flags & LOOKUP_IS_SCOPED))
8899f1fafeeSAl Viro nd->root.mnt = NULL;
8906c6ec2b0SJens Axboe nd->flags &= ~LOOKUP_CACHED;
891e36cffedSJens Axboe if (!try_to_unlazy(nd))
89248a066e7SAl Viro return -ECHILD;
89348a066e7SAl Viro }
8949f1fafeeSAl Viro
895adb21d2bSAleksa Sarai if (unlikely(nd->flags & LOOKUP_IS_SCOPED)) {
896adb21d2bSAleksa Sarai /*
897adb21d2bSAleksa Sarai * While the guarantee of LOOKUP_IS_SCOPED is (roughly) "don't
898adb21d2bSAleksa Sarai * ever step outside the root during lookup" and should already
899adb21d2bSAleksa Sarai * be guaranteed by the rest of namei, we want to avoid a namei
900adb21d2bSAleksa Sarai * BUG resulting in userspace being given a path that was not
901adb21d2bSAleksa Sarai * scoped within the root at some point during the lookup.
902adb21d2bSAleksa Sarai *
903adb21d2bSAleksa Sarai * So, do a final sanity-check to make sure that in the
904adb21d2bSAleksa Sarai * worst-case scenario (a complete bypass of LOOKUP_IS_SCOPED)
905adb21d2bSAleksa Sarai * we won't silently return an fd completely outside of the
906adb21d2bSAleksa Sarai * requested root to userspace.
907adb21d2bSAleksa Sarai *
908adb21d2bSAleksa Sarai * Userspace could move the path outside the root after this
909adb21d2bSAleksa Sarai * check, but as discussed elsewhere this is not a concern (the
910adb21d2bSAleksa Sarai * resolved file was inside the root at some point).
911adb21d2bSAleksa Sarai */
912adb21d2bSAleksa Sarai if (!path_is_under(&nd->path, &nd->root))
913adb21d2bSAleksa Sarai return -EXDEV;
914adb21d2bSAleksa Sarai }
915adb21d2bSAleksa Sarai
916bcba1e7dSAl Viro if (likely(!(nd->state & ND_JUMPED)))
91739159de2SJeff Layton return 0;
91839159de2SJeff Layton
919ecf3d1f1SJeff Layton if (likely(!(dentry->d_flags & DCACHE_OP_WEAK_REVALIDATE)))
92016c2cd71SAl Viro return 0;
92116c2cd71SAl Viro
922ecf3d1f1SJeff Layton status = dentry->d_op->d_weak_revalidate(dentry, nd->flags);
92339159de2SJeff Layton if (status > 0)
92439159de2SJeff Layton return 0;
92539159de2SJeff Layton
92616c2cd71SAl Viro if (!status)
92739159de2SJeff Layton status = -ESTALE;
92816c2cd71SAl Viro
92939159de2SJeff Layton return status;
93039159de2SJeff Layton }
93139159de2SJeff Layton
set_root(struct nameidata * nd)932740a1678SAleksa Sarai static int set_root(struct nameidata *nd)
9332a737871SAl Viro {
93431e6b01fSNick Piggin struct fs_struct *fs = current->fs;
9359e6697e2SAl Viro
936adb21d2bSAleksa Sarai /*
937adb21d2bSAleksa Sarai * Jumping to the real root in a scoped-lookup is a BUG in namei, but we
938adb21d2bSAleksa Sarai * still have to ensure it doesn't happen because it will cause a breakout
939adb21d2bSAleksa Sarai * from the dirfd.
940adb21d2bSAleksa Sarai */
941adb21d2bSAleksa Sarai if (WARN_ON(nd->flags & LOOKUP_IS_SCOPED))
942adb21d2bSAleksa Sarai return -ENOTRECOVERABLE;
943adb21d2bSAleksa Sarai
9449e6697e2SAl Viro if (nd->flags & LOOKUP_RCU) {
9458f47a016SAl Viro unsigned seq;
946c28cc364SNick Piggin
947c28cc364SNick Piggin do {
948c28cc364SNick Piggin seq = read_seqcount_begin(&fs->seq);
94931e6b01fSNick Piggin nd->root = fs->root;
9508f47a016SAl Viro nd->root_seq = __read_seqcount_begin(&nd->root.dentry->d_seq);
951c28cc364SNick Piggin } while (read_seqcount_retry(&fs->seq, seq));
9529e6697e2SAl Viro } else {
9539e6697e2SAl Viro get_fs_root(fs, &nd->root);
954bcba1e7dSAl Viro nd->state |= ND_ROOT_GRABBED;
9559e6697e2SAl Viro }
956740a1678SAleksa Sarai return 0;
95731e6b01fSNick Piggin }
95831e6b01fSNick Piggin
nd_jump_root(struct nameidata * nd)959248fb5b9SAl Viro static int nd_jump_root(struct nameidata *nd)
960248fb5b9SAl Viro {
961adb21d2bSAleksa Sarai if (unlikely(nd->flags & LOOKUP_BENEATH))
962adb21d2bSAleksa Sarai return -EXDEV;
96372ba2929SAleksa Sarai if (unlikely(nd->flags & LOOKUP_NO_XDEV)) {
96472ba2929SAleksa Sarai /* Absolute path arguments to path_init() are allowed. */
96572ba2929SAleksa Sarai if (nd->path.mnt != NULL && nd->path.mnt != nd->root.mnt)
96672ba2929SAleksa Sarai return -EXDEV;
96772ba2929SAleksa Sarai }
968740a1678SAleksa Sarai if (!nd->root.mnt) {
969740a1678SAleksa Sarai int error = set_root(nd);
970740a1678SAleksa Sarai if (error)
971740a1678SAleksa Sarai return error;
972740a1678SAleksa Sarai }
973248fb5b9SAl Viro if (nd->flags & LOOKUP_RCU) {
974248fb5b9SAl Viro struct dentry *d;
975248fb5b9SAl Viro nd->path = nd->root;
976248fb5b9SAl Viro d = nd->path.dentry;
977248fb5b9SAl Viro nd->inode = d->d_inode;
978248fb5b9SAl Viro nd->seq = nd->root_seq;
97982ef0698SAl Viro if (read_seqcount_retry(&d->d_seq, nd->seq))
980248fb5b9SAl Viro return -ECHILD;
981248fb5b9SAl Viro } else {
982248fb5b9SAl Viro path_put(&nd->path);
983248fb5b9SAl Viro nd->path = nd->root;
984248fb5b9SAl Viro path_get(&nd->path);
985248fb5b9SAl Viro nd->inode = nd->path.dentry->d_inode;
986248fb5b9SAl Viro }
987bcba1e7dSAl Viro nd->state |= ND_JUMPED;
988248fb5b9SAl Viro return 0;
989248fb5b9SAl Viro }
990248fb5b9SAl Viro
991b5fb63c1SChristoph Hellwig /*
9926b255391SAl Viro * Helper to directly jump to a known parsed path from ->get_link,
993b5fb63c1SChristoph Hellwig * caller must have taken a reference to path beforehand.
994b5fb63c1SChristoph Hellwig */
nd_jump_link(const struct path * path)995ea4af4aaSAl Viro int nd_jump_link(const struct path *path)
996b5fb63c1SChristoph Hellwig {
9974b99d499SAleksa Sarai int error = -ELOOP;
9986e77137bSAl Viro struct nameidata *nd = current->nameidata;
999b5fb63c1SChristoph Hellwig
10004b99d499SAleksa Sarai if (unlikely(nd->flags & LOOKUP_NO_MAGICLINKS))
10014b99d499SAleksa Sarai goto err;
10024b99d499SAleksa Sarai
100372ba2929SAleksa Sarai error = -EXDEV;
100472ba2929SAleksa Sarai if (unlikely(nd->flags & LOOKUP_NO_XDEV)) {
100572ba2929SAleksa Sarai if (nd->path.mnt != path->mnt)
100672ba2929SAleksa Sarai goto err;
100772ba2929SAleksa Sarai }
1008adb21d2bSAleksa Sarai /* Not currently safe for scoped-lookups. */
1009adb21d2bSAleksa Sarai if (unlikely(nd->flags & LOOKUP_IS_SCOPED))
1010adb21d2bSAleksa Sarai goto err;
101172ba2929SAleksa Sarai
10124b99d499SAleksa Sarai path_put(&nd->path);
1013b5fb63c1SChristoph Hellwig nd->path = *path;
1014b5fb63c1SChristoph Hellwig nd->inode = nd->path.dentry->d_inode;
1015bcba1e7dSAl Viro nd->state |= ND_JUMPED;
10161bc82070SAleksa Sarai return 0;
10174b99d499SAleksa Sarai
10184b99d499SAleksa Sarai err:
10194b99d499SAleksa Sarai path_put(path);
10204b99d499SAleksa Sarai return error;
1021b5fb63c1SChristoph Hellwig }
1022b5fb63c1SChristoph Hellwig
put_link(struct nameidata * nd)1023b9ff4429SAl Viro static inline void put_link(struct nameidata *nd)
1024574197e0SAl Viro {
102521c3003dSAl Viro struct saved *last = nd->stack + --nd->depth;
1026fceef393SAl Viro do_delayed_call(&last->done);
10276548fae2SAl Viro if (!(nd->flags & LOOKUP_RCU))
1028b9ff4429SAl Viro path_put(&last->link);
1029574197e0SAl Viro }
1030574197e0SAl Viro
10319c011be1SLuis Chamberlain static int sysctl_protected_symlinks __read_mostly;
10329c011be1SLuis Chamberlain static int sysctl_protected_hardlinks __read_mostly;
10339c011be1SLuis Chamberlain static int sysctl_protected_fifos __read_mostly;
10349c011be1SLuis Chamberlain static int sysctl_protected_regular __read_mostly;
10359c011be1SLuis Chamberlain
10369c011be1SLuis Chamberlain #ifdef CONFIG_SYSCTL
10379c011be1SLuis Chamberlain static struct ctl_table namei_sysctls[] = {
10389c011be1SLuis Chamberlain {
10399c011be1SLuis Chamberlain .procname = "protected_symlinks",
10409c011be1SLuis Chamberlain .data = &sysctl_protected_symlinks,
10419c011be1SLuis Chamberlain .maxlen = sizeof(int),
1042c7031c14SJulius Hemanth Pitti .mode = 0644,
10439c011be1SLuis Chamberlain .proc_handler = proc_dointvec_minmax,
10449c011be1SLuis Chamberlain .extra1 = SYSCTL_ZERO,
10459c011be1SLuis Chamberlain .extra2 = SYSCTL_ONE,
10469c011be1SLuis Chamberlain },
10479c011be1SLuis Chamberlain {
10489c011be1SLuis Chamberlain .procname = "protected_hardlinks",
10499c011be1SLuis Chamberlain .data = &sysctl_protected_hardlinks,
10509c011be1SLuis Chamberlain .maxlen = sizeof(int),
1051c7031c14SJulius Hemanth Pitti .mode = 0644,
10529c011be1SLuis Chamberlain .proc_handler = proc_dointvec_minmax,
10539c011be1SLuis Chamberlain .extra1 = SYSCTL_ZERO,
10549c011be1SLuis Chamberlain .extra2 = SYSCTL_ONE,
10559c011be1SLuis Chamberlain },
10569c011be1SLuis Chamberlain {
10579c011be1SLuis Chamberlain .procname = "protected_fifos",
10589c011be1SLuis Chamberlain .data = &sysctl_protected_fifos,
10599c011be1SLuis Chamberlain .maxlen = sizeof(int),
1060c7031c14SJulius Hemanth Pitti .mode = 0644,
10619c011be1SLuis Chamberlain .proc_handler = proc_dointvec_minmax,
10629c011be1SLuis Chamberlain .extra1 = SYSCTL_ZERO,
10639c011be1SLuis Chamberlain .extra2 = SYSCTL_TWO,
10649c011be1SLuis Chamberlain },
10659c011be1SLuis Chamberlain {
10669c011be1SLuis Chamberlain .procname = "protected_regular",
10679c011be1SLuis Chamberlain .data = &sysctl_protected_regular,
10689c011be1SLuis Chamberlain .maxlen = sizeof(int),
1069c7031c14SJulius Hemanth Pitti .mode = 0644,
10709c011be1SLuis Chamberlain .proc_handler = proc_dointvec_minmax,
10719c011be1SLuis Chamberlain .extra1 = SYSCTL_ZERO,
10729c011be1SLuis Chamberlain .extra2 = SYSCTL_TWO,
10739c011be1SLuis Chamberlain },
10749c011be1SLuis Chamberlain { }
10759c011be1SLuis Chamberlain };
10769c011be1SLuis Chamberlain
init_fs_namei_sysctls(void)10779c011be1SLuis Chamberlain static int __init init_fs_namei_sysctls(void)
10789c011be1SLuis Chamberlain {
10799c011be1SLuis Chamberlain register_sysctl_init("fs", namei_sysctls);
10809c011be1SLuis Chamberlain return 0;
10819c011be1SLuis Chamberlain }
10829c011be1SLuis Chamberlain fs_initcall(init_fs_namei_sysctls);
10839c011be1SLuis Chamberlain
10849c011be1SLuis Chamberlain #endif /* CONFIG_SYSCTL */
1085800179c9SKees Cook
1086800179c9SKees Cook /**
1087800179c9SKees Cook * may_follow_link - Check symlink following for unsafe situations
108855852635SRandy Dunlap * @nd: nameidata pathwalk data
108935931eb3SMatthew Wilcox (Oracle) * @inode: Used for idmapping.
1090800179c9SKees Cook *
1091800179c9SKees Cook * In the case of the sysctl_protected_symlinks sysctl being enabled,
1092800179c9SKees Cook * CAP_DAC_OVERRIDE needs to be specifically ignored if the symlink is
1093800179c9SKees Cook * in a sticky world-writable directory. This is to protect privileged
1094800179c9SKees Cook * processes from failing races against path names that may change out
1095800179c9SKees Cook * from under them by way of other users creating malicious symlinks.
1096800179c9SKees Cook * It will permit symlinks to be followed only when outside a sticky
1097800179c9SKees Cook * world-writable directory, or when the uid of the symlink and follower
1098800179c9SKees Cook * match, or when the directory owner matches the symlink's owner.
1099800179c9SKees Cook *
1100800179c9SKees Cook * Returns 0 if following the symlink is allowed, -ve on error.
1101800179c9SKees Cook */
may_follow_link(struct nameidata * nd,const struct inode * inode)1102ad6cc4c3SAl Viro static inline int may_follow_link(struct nameidata *nd, const struct inode *inode)
1103800179c9SKees Cook {
1104e67fe633SChristian Brauner struct mnt_idmap *idmap;
1105a2bd096fSChristian Brauner vfsuid_t vfsuid;
1106ba73d987SChristian Brauner
1107800179c9SKees Cook if (!sysctl_protected_symlinks)
1108800179c9SKees Cook return 0;
1109800179c9SKees Cook
1110e67fe633SChristian Brauner idmap = mnt_idmap(nd->path.mnt);
1111e67fe633SChristian Brauner vfsuid = i_uid_into_vfsuid(idmap, inode);
1112800179c9SKees Cook /* Allowed if owner and follower match. */
1113a2bd096fSChristian Brauner if (vfsuid_eq_kuid(vfsuid, current_fsuid()))
1114800179c9SKees Cook return 0;
1115800179c9SKees Cook
1116800179c9SKees Cook /* Allowed if parent directory not sticky and world-writable. */
11170f705953SAl Viro if ((nd->dir_mode & (S_ISVTX|S_IWOTH)) != (S_ISVTX|S_IWOTH))
1118800179c9SKees Cook return 0;
1119800179c9SKees Cook
1120800179c9SKees Cook /* Allowed if parent directory and link owner match. */
1121a2bd096fSChristian Brauner if (vfsuid_valid(nd->dir_vfsuid) && vfsuid_eq(nd->dir_vfsuid, vfsuid))
1122800179c9SKees Cook return 0;
1123800179c9SKees Cook
112431956502SAl Viro if (nd->flags & LOOKUP_RCU)
112531956502SAl Viro return -ECHILD;
112631956502SAl Viro
1127ea841bafSRichard Guy Briggs audit_inode(nd->name, nd->stack[0].link.dentry, 0);
1128245d7369SKees Cook audit_log_path_denied(AUDIT_ANOM_LINK, "follow_link");
1129800179c9SKees Cook return -EACCES;
1130800179c9SKees Cook }
1131800179c9SKees Cook
1132800179c9SKees Cook /**
1133800179c9SKees Cook * safe_hardlink_source - Check for safe hardlink conditions
11344609e1f1SChristian Brauner * @idmap: idmap of the mount the inode was found from
1135800179c9SKees Cook * @inode: the source inode to hardlink from
1136800179c9SKees Cook *
1137800179c9SKees Cook * Return false if at least one of the following conditions:
1138800179c9SKees Cook * - inode is not a regular file
1139800179c9SKees Cook * - inode is setuid
1140800179c9SKees Cook * - inode is setgid and group-exec
1141800179c9SKees Cook * - access failure for read and write
1142800179c9SKees Cook *
1143800179c9SKees Cook * Otherwise returns true.
1144800179c9SKees Cook */
safe_hardlink_source(struct mnt_idmap * idmap,struct inode * inode)11454609e1f1SChristian Brauner static bool safe_hardlink_source(struct mnt_idmap *idmap,
1146ba73d987SChristian Brauner struct inode *inode)
1147800179c9SKees Cook {
1148800179c9SKees Cook umode_t mode = inode->i_mode;
1149800179c9SKees Cook
1150800179c9SKees Cook /* Special files should not get pinned to the filesystem. */
1151800179c9SKees Cook if (!S_ISREG(mode))
1152800179c9SKees Cook return false;
1153800179c9SKees Cook
1154800179c9SKees Cook /* Setuid files should not get pinned to the filesystem. */
1155800179c9SKees Cook if (mode & S_ISUID)
1156800179c9SKees Cook return false;
1157800179c9SKees Cook
1158800179c9SKees Cook /* Executable setgid files should not get pinned to the filesystem. */
1159800179c9SKees Cook if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP))
1160800179c9SKees Cook return false;
1161800179c9SKees Cook
1162800179c9SKees Cook /* Hardlinking to unreadable or unwritable sources is dangerous. */
11634609e1f1SChristian Brauner if (inode_permission(idmap, inode, MAY_READ | MAY_WRITE))
1164800179c9SKees Cook return false;
1165800179c9SKees Cook
1166800179c9SKees Cook return true;
1167800179c9SKees Cook }
1168800179c9SKees Cook
1169800179c9SKees Cook /**
1170800179c9SKees Cook * may_linkat - Check permissions for creating a hardlink
11714609e1f1SChristian Brauner * @idmap: idmap of the mount the inode was found from
1172800179c9SKees Cook * @link: the source to hardlink from
1173800179c9SKees Cook *
1174800179c9SKees Cook * Block hardlink when all of:
1175800179c9SKees Cook * - sysctl_protected_hardlinks enabled
1176800179c9SKees Cook * - fsuid does not match inode
1177800179c9SKees Cook * - hardlink source is unsafe (see safe_hardlink_source() above)
1178f2ca3796SDirk Steinmetz * - not CAP_FOWNER in a namespace with the inode owner uid mapped
1179800179c9SKees Cook *
11804609e1f1SChristian Brauner * If the inode has been found through an idmapped mount the idmap of
11814609e1f1SChristian Brauner * the vfsmount must be passed through @idmap. This function will then take
11824609e1f1SChristian Brauner * care to map the inode according to @idmap before checking permissions.
1183ba73d987SChristian Brauner * On non-idmapped mounts or if permission checking is to be performed on the
11844609e1f1SChristian Brauner * raw inode simply pass @nop_mnt_idmap.
1185ba73d987SChristian Brauner *
1186800179c9SKees Cook * Returns 0 if successful, -ve on error.
1187800179c9SKees Cook */
may_linkat(struct mnt_idmap * idmap,const struct path * link)11884609e1f1SChristian Brauner int may_linkat(struct mnt_idmap *idmap, const struct path *link)
1189800179c9SKees Cook {
1190593d1ce8SEric W. Biederman struct inode *inode = link->dentry->d_inode;
1191593d1ce8SEric W. Biederman
1192593d1ce8SEric W. Biederman /* Inode writeback is not safe when the uid or gid are invalid. */
1193e67fe633SChristian Brauner if (!vfsuid_valid(i_uid_into_vfsuid(idmap, inode)) ||
1194e67fe633SChristian Brauner !vfsgid_valid(i_gid_into_vfsgid(idmap, inode)))
1195593d1ce8SEric W. Biederman return -EOVERFLOW;
1196800179c9SKees Cook
1197800179c9SKees Cook if (!sysctl_protected_hardlinks)
1198800179c9SKees Cook return 0;
1199800179c9SKees Cook
1200800179c9SKees Cook /* Source inode owner (or CAP_FOWNER) can hardlink all they like,
1201800179c9SKees Cook * otherwise, it must be a safe source.
1202800179c9SKees Cook */
12034609e1f1SChristian Brauner if (safe_hardlink_source(idmap, inode) ||
120401beba79SChristian Brauner inode_owner_or_capable(idmap, inode))
1205800179c9SKees Cook return 0;
1206800179c9SKees Cook
1207245d7369SKees Cook audit_log_path_denied(AUDIT_ANOM_LINK, "linkat");
1208800179c9SKees Cook return -EPERM;
1209800179c9SKees Cook }
1210800179c9SKees Cook
121130aba665SSalvatore Mesoraca /**
121230aba665SSalvatore Mesoraca * may_create_in_sticky - Check whether an O_CREAT open in a sticky directory
121330aba665SSalvatore Mesoraca * should be allowed, or not, on files that already
121430aba665SSalvatore Mesoraca * exist.
1215e67fe633SChristian Brauner * @idmap: idmap of the mount the inode was found from
12162111c3c0SRandy Dunlap * @nd: nameidata pathwalk data
121730aba665SSalvatore Mesoraca * @inode: the inode of the file to open
121830aba665SSalvatore Mesoraca *
121930aba665SSalvatore Mesoraca * Block an O_CREAT open of a FIFO (or a regular file) when:
122030aba665SSalvatore Mesoraca * - sysctl_protected_fifos (or sysctl_protected_regular) is enabled
122130aba665SSalvatore Mesoraca * - the file already exists
122230aba665SSalvatore Mesoraca * - we are in a sticky directory
122330aba665SSalvatore Mesoraca * - we don't own the file
122430aba665SSalvatore Mesoraca * - the owner of the directory doesn't own the file
122530aba665SSalvatore Mesoraca * - the directory is world writable
122630aba665SSalvatore Mesoraca * If the sysctl_protected_fifos (or sysctl_protected_regular) is set to 2
122730aba665SSalvatore Mesoraca * the directory doesn't have to be world writable: being group writable will
122830aba665SSalvatore Mesoraca * be enough.
122930aba665SSalvatore Mesoraca *
1230e67fe633SChristian Brauner * If the inode has been found through an idmapped mount the idmap of
1231e67fe633SChristian Brauner * the vfsmount must be passed through @idmap. This function will then take
1232e67fe633SChristian Brauner * care to map the inode according to @idmap before checking permissions.
1233ba73d987SChristian Brauner * On non-idmapped mounts or if permission checking is to be performed on the
1234e67fe633SChristian Brauner * raw inode simply pass @nop_mnt_idmap.
1235ba73d987SChristian Brauner *
123630aba665SSalvatore Mesoraca * Returns 0 if the open is allowed, -ve on error.
123730aba665SSalvatore Mesoraca */
may_create_in_sticky(struct mnt_idmap * idmap,struct nameidata * nd,struct inode * const inode)1238e67fe633SChristian Brauner static int may_create_in_sticky(struct mnt_idmap *idmap,
1239ba73d987SChristian Brauner struct nameidata *nd, struct inode *const inode)
124030aba665SSalvatore Mesoraca {
1241ba73d987SChristian Brauner umode_t dir_mode = nd->dir_mode;
1242a2bd096fSChristian Brauner vfsuid_t dir_vfsuid = nd->dir_vfsuid;
1243ba73d987SChristian Brauner
124430aba665SSalvatore Mesoraca if ((!sysctl_protected_fifos && S_ISFIFO(inode->i_mode)) ||
124530aba665SSalvatore Mesoraca (!sysctl_protected_regular && S_ISREG(inode->i_mode)) ||
1246d0cb5018SAl Viro likely(!(dir_mode & S_ISVTX)) ||
1247e67fe633SChristian Brauner vfsuid_eq(i_uid_into_vfsuid(idmap, inode), dir_vfsuid) ||
1248e67fe633SChristian Brauner vfsuid_eq_kuid(i_uid_into_vfsuid(idmap, inode), current_fsuid()))
124930aba665SSalvatore Mesoraca return 0;
125030aba665SSalvatore Mesoraca
1251d0cb5018SAl Viro if (likely(dir_mode & 0002) ||
1252d0cb5018SAl Viro (dir_mode & 0020 &&
125330aba665SSalvatore Mesoraca ((sysctl_protected_fifos >= 2 && S_ISFIFO(inode->i_mode)) ||
125430aba665SSalvatore Mesoraca (sysctl_protected_regular >= 2 && S_ISREG(inode->i_mode))))) {
1255245d7369SKees Cook const char *operation = S_ISFIFO(inode->i_mode) ?
1256245d7369SKees Cook "sticky_create_fifo" :
1257245d7369SKees Cook "sticky_create_regular";
1258245d7369SKees Cook audit_log_path_denied(AUDIT_ANOM_CREAT, operation);
125930aba665SSalvatore Mesoraca return -EACCES;
126030aba665SSalvatore Mesoraca }
126130aba665SSalvatore Mesoraca return 0;
126230aba665SSalvatore Mesoraca }
126330aba665SSalvatore Mesoraca
1264f015f126SDavid Howells /*
1265f015f126SDavid Howells * follow_up - Find the mountpoint of path's vfsmount
1266f015f126SDavid Howells *
1267f015f126SDavid Howells * Given a path, find the mountpoint of its source file system.
1268f015f126SDavid Howells * Replace @path with the path of the mountpoint in the parent mount.
1269f015f126SDavid Howells * Up is towards /.
1270f015f126SDavid Howells *
1271f015f126SDavid Howells * Return 1 if we went up a level and 0 if we were already at the
1272f015f126SDavid Howells * root.
1273f015f126SDavid Howells */
follow_up(struct path * path)1274bab77ebfSAl Viro int follow_up(struct path *path)
12751da177e4SLinus Torvalds {
12760714a533SAl Viro struct mount *mnt = real_mount(path->mnt);
12770714a533SAl Viro struct mount *parent;
12781da177e4SLinus Torvalds struct dentry *mountpoint;
127999b7db7bSNick Piggin
128048a066e7SAl Viro read_seqlock_excl(&mount_lock);
12810714a533SAl Viro parent = mnt->mnt_parent;
12823c0a6163SAl Viro if (parent == mnt) {
128348a066e7SAl Viro read_sequnlock_excl(&mount_lock);
12841da177e4SLinus Torvalds return 0;
12851da177e4SLinus Torvalds }
12860714a533SAl Viro mntget(&parent->mnt);
1287a73324daSAl Viro mountpoint = dget(mnt->mnt_mountpoint);
128848a066e7SAl Viro read_sequnlock_excl(&mount_lock);
1289bab77ebfSAl Viro dput(path->dentry);
1290bab77ebfSAl Viro path->dentry = mountpoint;
1291bab77ebfSAl Viro mntput(path->mnt);
12920714a533SAl Viro path->mnt = &parent->mnt;
12931da177e4SLinus Torvalds return 1;
12941da177e4SLinus Torvalds }
12954d359507SAl Viro EXPORT_SYMBOL(follow_up);
12961da177e4SLinus Torvalds
choose_mountpoint_rcu(struct mount * m,const struct path * root,struct path * path,unsigned * seqp)12977ef482faSAl Viro static bool choose_mountpoint_rcu(struct mount *m, const struct path *root,
12987ef482faSAl Viro struct path *path, unsigned *seqp)
12997ef482faSAl Viro {
13007ef482faSAl Viro while (mnt_has_parent(m)) {
13017ef482faSAl Viro struct dentry *mountpoint = m->mnt_mountpoint;
13027ef482faSAl Viro
13037ef482faSAl Viro m = m->mnt_parent;
13047ef482faSAl Viro if (unlikely(root->dentry == mountpoint &&
13057ef482faSAl Viro root->mnt == &m->mnt))
13067ef482faSAl Viro break;
13077ef482faSAl Viro if (mountpoint != m->mnt.mnt_root) {
13087ef482faSAl Viro path->mnt = &m->mnt;
13097ef482faSAl Viro path->dentry = mountpoint;
13107ef482faSAl Viro *seqp = read_seqcount_begin(&mountpoint->d_seq);
13117ef482faSAl Viro return true;
13127ef482faSAl Viro }
13137ef482faSAl Viro }
13147ef482faSAl Viro return false;
13157ef482faSAl Viro }
13167ef482faSAl Viro
choose_mountpoint(struct mount * m,const struct path * root,struct path * path)13172aa38470SAl Viro static bool choose_mountpoint(struct mount *m, const struct path *root,
13182aa38470SAl Viro struct path *path)
13192aa38470SAl Viro {
13202aa38470SAl Viro bool found;
13212aa38470SAl Viro
13222aa38470SAl Viro rcu_read_lock();
13232aa38470SAl Viro while (1) {
13242aa38470SAl Viro unsigned seq, mseq = read_seqbegin(&mount_lock);
13252aa38470SAl Viro
13262aa38470SAl Viro found = choose_mountpoint_rcu(m, root, path, &seq);
13272aa38470SAl Viro if (unlikely(!found)) {
13282aa38470SAl Viro if (!read_seqretry(&mount_lock, mseq))
13292aa38470SAl Viro break;
13302aa38470SAl Viro } else {
13312aa38470SAl Viro if (likely(__legitimize_path(path, seq, mseq)))
13322aa38470SAl Viro break;
13332aa38470SAl Viro rcu_read_unlock();
13342aa38470SAl Viro path_put(path);
13352aa38470SAl Viro rcu_read_lock();
13362aa38470SAl Viro }
13372aa38470SAl Viro }
13382aa38470SAl Viro rcu_read_unlock();
13392aa38470SAl Viro return found;
13402aa38470SAl Viro }
13412aa38470SAl Viro
1342b5c84bf6SNick Piggin /*
13439875cf80SDavid Howells * Perform an automount
13449875cf80SDavid Howells * - return -EISDIR to tell follow_managed() to stop and return the path we
13459875cf80SDavid Howells * were called with.
13461da177e4SLinus Torvalds */
follow_automount(struct path * path,int * count,unsigned lookup_flags)13471c9f5e06SAl Viro static int follow_automount(struct path *path, int *count, unsigned lookup_flags)
134831e6b01fSNick Piggin {
134925e195aaSAl Viro struct dentry *dentry = path->dentry;
13509875cf80SDavid Howells
13510ec26fd0SMiklos Szeredi /* We don't want to mount if someone's just doing a stat -
13520ec26fd0SMiklos Szeredi * unless they're stat'ing a directory and appended a '/' to
13530ec26fd0SMiklos Szeredi * the name.
13540ec26fd0SMiklos Szeredi *
13550ec26fd0SMiklos Szeredi * We do, however, want to mount if someone wants to open or
13565a30d8a2SDavid Howells * create a file of any type under the mountpoint, wants to
13570ec26fd0SMiklos Szeredi * traverse through the mountpoint or wants to open the
13580ec26fd0SMiklos Szeredi * mounted directory. Also, autofs may mark negative dentries
13590ec26fd0SMiklos Szeredi * as being automount points. These will need the attentions
13600ec26fd0SMiklos Szeredi * of the daemon to instantiate them before they can be used.
13615a30d8a2SDavid Howells */
13621c9f5e06SAl Viro if (!(lookup_flags & (LOOKUP_PARENT | LOOKUP_DIRECTORY |
13635d38f049SIan Kent LOOKUP_OPEN | LOOKUP_CREATE | LOOKUP_AUTOMOUNT)) &&
136425e195aaSAl Viro dentry->d_inode)
13659875cf80SDavid Howells return -EISDIR;
13660ec26fd0SMiklos Szeredi
13671c9f5e06SAl Viro if (count && (*count)++ >= MAXSYMLINKS)
13689875cf80SDavid Howells return -ELOOP;
13699875cf80SDavid Howells
137025e195aaSAl Viro return finish_automount(dentry->d_op->d_automount(path), path);
1371ea5b778aSDavid Howells }
13729875cf80SDavid Howells
13739875cf80SDavid Howells /*
13749deed3ebSAl Viro * mount traversal - out-of-line part. One note on ->d_flags accesses -
13759deed3ebSAl Viro * dentries are pinned but not locked here, so negative dentry can go
13769deed3ebSAl Viro * positive right under us. Use of smp_load_acquire() provides a barrier
13779deed3ebSAl Viro * sufficient for ->d_inode and ->d_flags consistency.
13789875cf80SDavid Howells */
__traverse_mounts(struct path * path,unsigned flags,bool * jumped,int * count,unsigned lookup_flags)13799deed3ebSAl Viro static int __traverse_mounts(struct path *path, unsigned flags, bool *jumped,
13809deed3ebSAl Viro int *count, unsigned lookup_flags)
13819875cf80SDavid Howells {
13829deed3ebSAl Viro struct vfsmount *mnt = path->mnt;
13839875cf80SDavid Howells bool need_mntput = false;
13848aef1884SAl Viro int ret = 0;
13859875cf80SDavid Howells
13869deed3ebSAl Viro while (flags & DCACHE_MANAGED_DENTRY) {
1387cc53ce53SDavid Howells /* Allow the filesystem to manage the transit without i_mutex
1388cc53ce53SDavid Howells * being held. */
1389d41efb52SAl Viro if (flags & DCACHE_MANAGE_TRANSIT) {
1390fb5f51c7SIan Kent ret = path->dentry->d_op->d_manage(path, false);
1391508c8772SAl Viro flags = smp_load_acquire(&path->dentry->d_flags);
1392cc53ce53SDavid Howells if (ret < 0)
13938aef1884SAl Viro break;
1394cc53ce53SDavid Howells }
1395cc53ce53SDavid Howells
13969deed3ebSAl Viro if (flags & DCACHE_MOUNTED) { // something's mounted on it..
13979875cf80SDavid Howells struct vfsmount *mounted = lookup_mnt(path);
13989deed3ebSAl Viro if (mounted) { // ... in our namespace
13999875cf80SDavid Howells dput(path->dentry);
14009875cf80SDavid Howells if (need_mntput)
1401463ffb2eSAl Viro mntput(path->mnt);
1402463ffb2eSAl Viro path->mnt = mounted;
1403463ffb2eSAl Viro path->dentry = dget(mounted->mnt_root);
14049deed3ebSAl Viro // here we know it's positive
14059deed3ebSAl Viro flags = path->dentry->d_flags;
14069875cf80SDavid Howells need_mntput = true;
14079875cf80SDavid Howells continue;
1408463ffb2eSAl Viro }
14091da177e4SLinus Torvalds }
14109875cf80SDavid Howells
14119deed3ebSAl Viro if (!(flags & DCACHE_NEED_AUTOMOUNT))
14129deed3ebSAl Viro break;
14139deed3ebSAl Viro
14149deed3ebSAl Viro // uncovered automount point
14159deed3ebSAl Viro ret = follow_automount(path, count, lookup_flags);
14169deed3ebSAl Viro flags = smp_load_acquire(&path->dentry->d_flags);
14179875cf80SDavid Howells if (ret < 0)
14188aef1884SAl Viro break;
14199875cf80SDavid Howells }
14209875cf80SDavid Howells
14219deed3ebSAl Viro if (ret == -EISDIR)
14229deed3ebSAl Viro ret = 0;
14239deed3ebSAl Viro // possible if you race with several mount --move
14249deed3ebSAl Viro if (need_mntput && path->mnt == mnt)
14258aef1884SAl Viro mntput(path->mnt);
14269deed3ebSAl Viro if (!ret && unlikely(d_flags_negative(flags)))
1427d41efb52SAl Viro ret = -ENOENT;
14289deed3ebSAl Viro *jumped = need_mntput;
14298402752eSAl Viro return ret;
14301da177e4SLinus Torvalds }
14311da177e4SLinus Torvalds
traverse_mounts(struct path * path,bool * jumped,int * count,unsigned lookup_flags)14329deed3ebSAl Viro static inline int traverse_mounts(struct path *path, bool *jumped,
14339deed3ebSAl Viro int *count, unsigned lookup_flags)
14349deed3ebSAl Viro {
14359deed3ebSAl Viro unsigned flags = smp_load_acquire(&path->dentry->d_flags);
14369deed3ebSAl Viro
14379deed3ebSAl Viro /* fastpath */
14389deed3ebSAl Viro if (likely(!(flags & DCACHE_MANAGED_DENTRY))) {
14399deed3ebSAl Viro *jumped = false;
14409deed3ebSAl Viro if (unlikely(d_flags_negative(flags)))
14419deed3ebSAl Viro return -ENOENT;
14429deed3ebSAl Viro return 0;
14439deed3ebSAl Viro }
14449deed3ebSAl Viro return __traverse_mounts(path, flags, jumped, count, lookup_flags);
14459deed3ebSAl Viro }
14469deed3ebSAl Viro
follow_down_one(struct path * path)1447cc53ce53SDavid Howells int follow_down_one(struct path *path)
14481da177e4SLinus Torvalds {
14491da177e4SLinus Torvalds struct vfsmount *mounted;
14501da177e4SLinus Torvalds
14511c755af4SAl Viro mounted = lookup_mnt(path);
14521da177e4SLinus Torvalds if (mounted) {
14539393bd07SAl Viro dput(path->dentry);
14549393bd07SAl Viro mntput(path->mnt);
14559393bd07SAl Viro path->mnt = mounted;
14569393bd07SAl Viro path->dentry = dget(mounted->mnt_root);
14571da177e4SLinus Torvalds return 1;
14581da177e4SLinus Torvalds }
14591da177e4SLinus Torvalds return 0;
14601da177e4SLinus Torvalds }
14614d359507SAl Viro EXPORT_SYMBOL(follow_down_one);
14621da177e4SLinus Torvalds
14639875cf80SDavid Howells /*
14649deed3ebSAl Viro * Follow down to the covering mount currently visible to userspace. At each
14659deed3ebSAl Viro * point, the filesystem owning that dentry may be queried as to whether the
14669deed3ebSAl Viro * caller is permitted to proceed or not.
14679deed3ebSAl Viro */
follow_down(struct path * path,unsigned int flags)1468e1f19857SRichard Weinberger int follow_down(struct path *path, unsigned int flags)
14699deed3ebSAl Viro {
14709deed3ebSAl Viro struct vfsmount *mnt = path->mnt;
14719deed3ebSAl Viro bool jumped;
1472e1f19857SRichard Weinberger int ret = traverse_mounts(path, &jumped, NULL, flags);
14739deed3ebSAl Viro
14749deed3ebSAl Viro if (path->mnt != mnt)
14759deed3ebSAl Viro mntput(mnt);
14769deed3ebSAl Viro return ret;
14779deed3ebSAl Viro }
14789deed3ebSAl Viro EXPORT_SYMBOL(follow_down);
14799deed3ebSAl Viro
14809deed3ebSAl Viro /*
1481287548e4SAl Viro * Try to skip to top of mountpoint pile in rcuwalk mode. Fail if
1482287548e4SAl Viro * we meet a managed dentry that would need blocking.
14839875cf80SDavid Howells */
__follow_mount_rcu(struct nameidata * nd,struct path * path)14843bd8bc89SAl Viro static bool __follow_mount_rcu(struct nameidata *nd, struct path *path)
14859875cf80SDavid Howells {
1486ea936aebSAl Viro struct dentry *dentry = path->dentry;
1487ea936aebSAl Viro unsigned int flags = dentry->d_flags;
1488ea936aebSAl Viro
1489ea936aebSAl Viro if (likely(!(flags & DCACHE_MANAGED_DENTRY)))
1490ea936aebSAl Viro return true;
1491ea936aebSAl Viro
1492ea936aebSAl Viro if (unlikely(nd->flags & LOOKUP_NO_XDEV))
1493ea936aebSAl Viro return false;
1494ea936aebSAl Viro
149562a7375eSIan Kent for (;;) {
149662a7375eSIan Kent /*
149762a7375eSIan Kent * Don't forget we might have a non-mountpoint managed dentry
149862a7375eSIan Kent * that wants to block transit.
149962a7375eSIan Kent */
1500ea936aebSAl Viro if (unlikely(flags & DCACHE_MANAGE_TRANSIT)) {
1501ea936aebSAl Viro int res = dentry->d_op->d_manage(path, true);
1502ea936aebSAl Viro if (res)
1503ea936aebSAl Viro return res == -EISDIR;
1504ea936aebSAl Viro flags = dentry->d_flags;
1505b8faf035SNeilBrown }
150662a7375eSIan Kent
1507ea936aebSAl Viro if (flags & DCACHE_MOUNTED) {
1508ea936aebSAl Viro struct mount *mounted = __lookup_mnt(path->mnt, dentry);
1509ea936aebSAl Viro if (mounted) {
1510c7105365SAl Viro path->mnt = &mounted->mnt;
1511ea936aebSAl Viro dentry = path->dentry = mounted->mnt.mnt_root;
1512bcba1e7dSAl Viro nd->state |= ND_JUMPED;
151303fa86e9SAl Viro nd->next_seq = read_seqcount_begin(&dentry->d_seq);
1514ea936aebSAl Viro flags = dentry->d_flags;
151503fa86e9SAl Viro // makes sure that non-RCU pathwalk could reach
151603fa86e9SAl Viro // this state.
151720aac6c6SAl Viro if (read_seqretry(&mount_lock, nd->m_seq))
151820aac6c6SAl Viro return false;
1519ea936aebSAl Viro continue;
15209875cf80SDavid Howells }
1521ea936aebSAl Viro if (read_seqretry(&mount_lock, nd->m_seq))
1522ea936aebSAl Viro return false;
1523ea936aebSAl Viro }
1524ea936aebSAl Viro return !(flags & DCACHE_NEED_AUTOMOUNT);
1525ea936aebSAl Viro }
1526287548e4SAl Viro }
1527287548e4SAl Viro
handle_mounts(struct nameidata * nd,struct dentry * dentry,struct path * path)1528db3c9adeSAl Viro static inline int handle_mounts(struct nameidata *nd, struct dentry *dentry,
15293bd8bc89SAl Viro struct path *path)
1530bd7c4b50SAl Viro {
15319deed3ebSAl Viro bool jumped;
1532db3c9adeSAl Viro int ret;
1533bd7c4b50SAl Viro
1534db3c9adeSAl Viro path->mnt = nd->path.mnt;
1535db3c9adeSAl Viro path->dentry = dentry;
1536c153007bSAl Viro if (nd->flags & LOOKUP_RCU) {
153703fa86e9SAl Viro unsigned int seq = nd->next_seq;
15383bd8bc89SAl Viro if (likely(__follow_mount_rcu(nd, path)))
15399deed3ebSAl Viro return 0;
154003fa86e9SAl Viro // *path and nd->next_seq might've been clobbered
1541c153007bSAl Viro path->mnt = nd->path.mnt;
1542c153007bSAl Viro path->dentry = dentry;
154303fa86e9SAl Viro nd->next_seq = seq;
154403fa86e9SAl Viro if (!try_to_unlazy_next(nd, dentry))
154503fa86e9SAl Viro return -ECHILD;
1546c153007bSAl Viro }
15479deed3ebSAl Viro ret = traverse_mounts(path, &jumped, &nd->total_link_count, nd->flags);
15489deed3ebSAl Viro if (jumped) {
15499deed3ebSAl Viro if (unlikely(nd->flags & LOOKUP_NO_XDEV))
15509deed3ebSAl Viro ret = -EXDEV;
15519deed3ebSAl Viro else
1552bcba1e7dSAl Viro nd->state |= ND_JUMPED;
15539deed3ebSAl Viro }
15549deed3ebSAl Viro if (unlikely(ret)) {
15559deed3ebSAl Viro dput(path->dentry);
15569deed3ebSAl Viro if (path->mnt != nd->path.mnt)
15579deed3ebSAl Viro mntput(path->mnt);
1558bd7c4b50SAl Viro }
1559bd7c4b50SAl Viro return ret;
1560bd7c4b50SAl Viro }
1561bd7c4b50SAl Viro
15629875cf80SDavid Howells /*
1563f4fdace9SOleg Drokin * This looks up the name in dcache and possibly revalidates the found dentry.
1564f4fdace9SOleg Drokin * NULL is returned if the dentry does not exist in the cache.
1565baa03890SNick Piggin */
lookup_dcache(const struct qstr * name,struct dentry * dir,unsigned int flags)1566e3c13928SAl Viro static struct dentry *lookup_dcache(const struct qstr *name,
1567e3c13928SAl Viro struct dentry *dir,
15686c51e513SAl Viro unsigned int flags)
1569baa03890SNick Piggin {
1570a89f8337SAl Viro struct dentry *dentry = d_lookup(dir, name);
1571bad61189SMiklos Szeredi if (dentry) {
1572a89f8337SAl Viro int error = d_revalidate(dentry, flags);
1573bad61189SMiklos Szeredi if (unlikely(error <= 0)) {
157474ff0ffcSAl Viro if (!error)
15755542aa2fSEric W. Biederman d_invalidate(dentry);
1576bad61189SMiklos Szeredi dput(dentry);
157774ff0ffcSAl Viro return ERR_PTR(error);
1578bad61189SMiklos Szeredi }
1579bad61189SMiklos Szeredi }
1580baa03890SNick Piggin return dentry;
1581baa03890SNick Piggin }
1582baa03890SNick Piggin
1583baa03890SNick Piggin /*
1584a03ece5fSAl Viro * Parent directory has inode locked exclusive. This is one
1585a03ece5fSAl Viro * and only case when ->lookup() gets called on non in-lookup
1586a03ece5fSAl Viro * dentries - as the matter of fact, this only gets called
1587a03ece5fSAl Viro * when directory is guaranteed to have no in-lookup children
1588a03ece5fSAl Viro * at all.
158944396f4bSJosef Bacik */
lookup_one_qstr_excl(const struct qstr * name,struct dentry * base,unsigned int flags)159074d7970fSNamjae Jeon struct dentry *lookup_one_qstr_excl(const struct qstr *name,
159174d7970fSNamjae Jeon struct dentry *base,
159274d7970fSNamjae Jeon unsigned int flags)
159344396f4bSJosef Bacik {
1594a03ece5fSAl Viro struct dentry *dentry = lookup_dcache(name, base, flags);
159544396f4bSJosef Bacik struct dentry *old;
1596a03ece5fSAl Viro struct inode *dir = base->d_inode;
1597a03ece5fSAl Viro
1598a03ece5fSAl Viro if (dentry)
1599a03ece5fSAl Viro return dentry;
160044396f4bSJosef Bacik
160144396f4bSJosef Bacik /* Don't create child dentry for a dead directory. */
1602a03ece5fSAl Viro if (unlikely(IS_DEADDIR(dir)))
160344396f4bSJosef Bacik return ERR_PTR(-ENOENT);
1604a03ece5fSAl Viro
1605a03ece5fSAl Viro dentry = d_alloc(base, name);
1606a03ece5fSAl Viro if (unlikely(!dentry))
1607a03ece5fSAl Viro return ERR_PTR(-ENOMEM);
160844396f4bSJosef Bacik
160972bd866aSAl Viro old = dir->i_op->lookup(dir, dentry, flags);
161044396f4bSJosef Bacik if (unlikely(old)) {
161144396f4bSJosef Bacik dput(dentry);
161244396f4bSJosef Bacik dentry = old;
161344396f4bSJosef Bacik }
161444396f4bSJosef Bacik return dentry;
161544396f4bSJosef Bacik }
161674d7970fSNamjae Jeon EXPORT_SYMBOL(lookup_one_qstr_excl);
161744396f4bSJosef Bacik
lookup_fast(struct nameidata * nd)16184cb64024SAl Viro static struct dentry *lookup_fast(struct nameidata *nd)
16191da177e4SLinus Torvalds {
162031e6b01fSNick Piggin struct dentry *dentry, *parent = nd->path.dentry;
16215a18fff2SAl Viro int status = 1;
16229875cf80SDavid Howells
16233cac260aSAl Viro /*
1624b04f784eSNick Piggin * Rename seqlock is not required here because in the off chance
16255d0f49c1SAl Viro * of a false negative due to a concurrent rename, the caller is
16265d0f49c1SAl Viro * going to fall back to non-racy lookup.
1627b04f784eSNick Piggin */
162831e6b01fSNick Piggin if (nd->flags & LOOKUP_RCU) {
162903fa86e9SAl Viro dentry = __d_lookup_rcu(parent, &nd->last, &nd->next_seq);
16305d0f49c1SAl Viro if (unlikely(!dentry)) {
1631e36cffedSJens Axboe if (!try_to_unlazy(nd))
163220e34357SAl Viro return ERR_PTR(-ECHILD);
163320e34357SAl Viro return NULL;
16345d0f49c1SAl Viro }
16355a18fff2SAl Viro
163612f8ad4bSLinus Torvalds /*
163712f8ad4bSLinus Torvalds * This sequence count validates that the parent had no
163812f8ad4bSLinus Torvalds * changes while we did the lookup of the dentry above.
163912f8ad4bSLinus Torvalds */
16404cb64024SAl Viro if (read_seqcount_retry(&parent->d_seq, nd->seq))
164120e34357SAl Viro return ERR_PTR(-ECHILD);
16425a18fff2SAl Viro
16434ce16ef3SAl Viro status = d_revalidate(dentry, nd->flags);
1644c153007bSAl Viro if (likely(status > 0))
164520e34357SAl Viro return dentry;
164603fa86e9SAl Viro if (!try_to_unlazy_next(nd, dentry))
164720e34357SAl Viro return ERR_PTR(-ECHILD);
164826ddb45eSSteven Rostedt (VMware) if (status == -ECHILD)
1649209a7fb2SAl Viro /* we'd been told to redo it in non-rcu mode */
1650209a7fb2SAl Viro status = d_revalidate(dentry, nd->flags);
16515a18fff2SAl Viro } else {
1652e97cdc87SAl Viro dentry = __d_lookup(parent, &nd->last);
165381e6f520SAl Viro if (unlikely(!dentry))
165420e34357SAl Viro return NULL;
16554ce16ef3SAl Viro status = d_revalidate(dentry, nd->flags);
16565d0f49c1SAl Viro }
16575a18fff2SAl Viro if (unlikely(status <= 0)) {
1658e9742b53SAl Viro if (!status)
16595d0f49c1SAl Viro d_invalidate(dentry);
16605a18fff2SAl Viro dput(dentry);
166120e34357SAl Viro return ERR_PTR(status);
16625a18fff2SAl Viro }
166320e34357SAl Viro return dentry;
1664697f514dSMiklos Szeredi }
1665697f514dSMiklos Szeredi
1666697f514dSMiklos Szeredi /* Fast lookup failed, do it the slow way */
__lookup_slow(const struct qstr * name,struct dentry * dir,unsigned int flags)166788d8331aSAl Viro static struct dentry *__lookup_slow(const struct qstr *name,
1668e3c13928SAl Viro struct dentry *dir,
1669e3c13928SAl Viro unsigned int flags)
1670697f514dSMiklos Szeredi {
167188d8331aSAl Viro struct dentry *dentry, *old;
16721936386eSAl Viro struct inode *inode = dir->d_inode;
1673d9171b93SAl Viro DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
16741936386eSAl Viro
16751936386eSAl Viro /* Don't go there if it's already dead */
167694bdd655SAl Viro if (unlikely(IS_DEADDIR(inode)))
167788d8331aSAl Viro return ERR_PTR(-ENOENT);
167894bdd655SAl Viro again:
1679d9171b93SAl Viro dentry = d_alloc_parallel(dir, name, &wq);
168094bdd655SAl Viro if (IS_ERR(dentry))
168188d8331aSAl Viro return dentry;
168294bdd655SAl Viro if (unlikely(!d_in_lookup(dentry))) {
1683949a852eSAl Viro int error = d_revalidate(dentry, flags);
1684949a852eSAl Viro if (unlikely(error <= 0)) {
168594bdd655SAl Viro if (!error) {
1686949a852eSAl Viro d_invalidate(dentry);
1687949a852eSAl Viro dput(dentry);
168894bdd655SAl Viro goto again;
168994bdd655SAl Viro }
169094bdd655SAl Viro dput(dentry);
1691949a852eSAl Viro dentry = ERR_PTR(error);
1692949a852eSAl Viro }
169394bdd655SAl Viro } else {
16941936386eSAl Viro old = inode->i_op->lookup(inode, dentry, flags);
169585c7f810SAl Viro d_lookup_done(dentry);
16961936386eSAl Viro if (unlikely(old)) {
16971936386eSAl Viro dput(dentry);
16981936386eSAl Viro dentry = old;
1699949a852eSAl Viro }
1700949a852eSAl Viro }
1701e3c13928SAl Viro return dentry;
17021da177e4SLinus Torvalds }
17031da177e4SLinus Torvalds
lookup_slow(const struct qstr * name,struct dentry * dir,unsigned int flags)170488d8331aSAl Viro static struct dentry *lookup_slow(const struct qstr *name,
170588d8331aSAl Viro struct dentry *dir,
170688d8331aSAl Viro unsigned int flags)
170788d8331aSAl Viro {
170888d8331aSAl Viro struct inode *inode = dir->d_inode;
170988d8331aSAl Viro struct dentry *res;
171088d8331aSAl Viro inode_lock_shared(inode);
171188d8331aSAl Viro res = __lookup_slow(name, dir, flags);
171288d8331aSAl Viro inode_unlock_shared(inode);
171388d8331aSAl Viro return res;
171488d8331aSAl Viro }
171588d8331aSAl Viro
may_lookup(struct mnt_idmap * idmap,struct nameidata * nd)17164609e1f1SChristian Brauner static inline int may_lookup(struct mnt_idmap *idmap,
1717ba73d987SChristian Brauner struct nameidata *nd)
171852094c8aSAl Viro {
171952094c8aSAl Viro if (nd->flags & LOOKUP_RCU) {
17204609e1f1SChristian Brauner int err = inode_permission(idmap, nd->inode, MAY_EXEC|MAY_NOT_BLOCK);
1721e36cffedSJens Axboe if (err != -ECHILD || !try_to_unlazy(nd))
172252094c8aSAl Viro return err;
172352094c8aSAl Viro }
17244609e1f1SChristian Brauner return inode_permission(idmap, nd->inode, MAY_EXEC);
172552094c8aSAl Viro }
172652094c8aSAl Viro
reserve_stack(struct nameidata * nd,struct path * link)172703fa86e9SAl Viro static int reserve_stack(struct nameidata *nd, struct path *link)
1728d63ff28fSAl Viro {
172949055906SAl Viro if (unlikely(nd->total_link_count++ >= MAXSYMLINKS))
173049055906SAl Viro return -ELOOP;
17314542576bSAl Viro
17324542576bSAl Viro if (likely(nd->depth != EMBEDDED_LEVELS))
17334542576bSAl Viro return 0;
17344542576bSAl Viro if (likely(nd->stack != nd->internal))
17354542576bSAl Viro return 0;
173660ef60c7SAl Viro if (likely(nd_alloc_stack(nd)))
173749055906SAl Viro return 0;
173860ef60c7SAl Viro
173960ef60c7SAl Viro if (nd->flags & LOOKUP_RCU) {
174060ef60c7SAl Viro // we need to grab link before we do unlazy. And we can't skip
174160ef60c7SAl Viro // unlazy even if we fail to grab the link - cleanup needs it
174203fa86e9SAl Viro bool grabbed_link = legitimize_path(nd, link, nd->next_seq);
174360ef60c7SAl Viro
1744e5ca024eSAl Viro if (!try_to_unlazy(nd) || !grabbed_link)
174560ef60c7SAl Viro return -ECHILD;
174660ef60c7SAl Viro
174760ef60c7SAl Viro if (nd_alloc_stack(nd))
174860ef60c7SAl Viro return 0;
1749bc40aee0SAl Viro }
175060ef60c7SAl Viro return -ENOMEM;
175149055906SAl Viro }
175249055906SAl Viro
175349055906SAl Viro enum {WALK_TRAILING = 1, WALK_MORE = 2, WALK_NOFOLLOW = 4};
175449055906SAl Viro
pick_link(struct nameidata * nd,struct path * link,struct inode * inode,int flags)175549055906SAl Viro static const char *pick_link(struct nameidata *nd, struct path *link,
175603fa86e9SAl Viro struct inode *inode, int flags)
175749055906SAl Viro {
175849055906SAl Viro struct saved *last;
175949055906SAl Viro const char *res;
176003fa86e9SAl Viro int error = reserve_stack(nd, link);
176149055906SAl Viro
176249055906SAl Viro if (unlikely(error)) {
176349055906SAl Viro if (!(nd->flags & LOOKUP_RCU))
1764cd179f44SAl Viro path_put(link);
176506708adbSAl Viro return ERR_PTR(error);
1766626de996SAl Viro }
1767ab104923SAl Viro last = nd->stack + nd->depth++;
17681cf2665bSAl Viro last->link = *link;
1769fceef393SAl Viro clear_delayed_call(&last->done);
177003fa86e9SAl Viro last->seq = nd->next_seq;
1771ad6cc4c3SAl Viro
1772b1a81972SAl Viro if (flags & WALK_TRAILING) {
1773ad6cc4c3SAl Viro error = may_follow_link(nd, inode);
1774ad6cc4c3SAl Viro if (unlikely(error))
1775ad6cc4c3SAl Viro return ERR_PTR(error);
1776ad6cc4c3SAl Viro }
1777ad6cc4c3SAl Viro
1778dab741e0SMattias Nissler if (unlikely(nd->flags & LOOKUP_NO_SYMLINKS) ||
1779dab741e0SMattias Nissler unlikely(link->mnt->mnt_flags & MNT_NOSYMFOLLOW))
1780ad6cc4c3SAl Viro return ERR_PTR(-ELOOP);
1781ad6cc4c3SAl Viro
1782ad6cc4c3SAl Viro if (!(nd->flags & LOOKUP_RCU)) {
1783ad6cc4c3SAl Viro touch_atime(&last->link);
1784ad6cc4c3SAl Viro cond_resched();
1785ad6cc4c3SAl Viro } else if (atime_needs_update(&last->link, inode)) {
1786e36cffedSJens Axboe if (!try_to_unlazy(nd))
1787ad6cc4c3SAl Viro return ERR_PTR(-ECHILD);
1788ad6cc4c3SAl Viro touch_atime(&last->link);
1789ad6cc4c3SAl Viro }
1790ad6cc4c3SAl Viro
1791ad6cc4c3SAl Viro error = security_inode_follow_link(link->dentry, inode,
1792ad6cc4c3SAl Viro nd->flags & LOOKUP_RCU);
1793ad6cc4c3SAl Viro if (unlikely(error))
1794ad6cc4c3SAl Viro return ERR_PTR(error);
1795ad6cc4c3SAl Viro
1796ad6cc4c3SAl Viro res = READ_ONCE(inode->i_link);
1797ad6cc4c3SAl Viro if (!res) {
1798ad6cc4c3SAl Viro const char * (*get)(struct dentry *, struct inode *,
1799ad6cc4c3SAl Viro struct delayed_call *);
1800ad6cc4c3SAl Viro get = inode->i_op->get_link;
1801ad6cc4c3SAl Viro if (nd->flags & LOOKUP_RCU) {
1802ad6cc4c3SAl Viro res = get(NULL, inode, &last->done);
1803e36cffedSJens Axboe if (res == ERR_PTR(-ECHILD) && try_to_unlazy(nd))
1804ad6cc4c3SAl Viro res = get(link->dentry, inode, &last->done);
1805ad6cc4c3SAl Viro } else {
1806ad6cc4c3SAl Viro res = get(link->dentry, inode, &last->done);
1807ad6cc4c3SAl Viro }
1808ad6cc4c3SAl Viro if (!res)
1809ad6cc4c3SAl Viro goto all_done;
1810ad6cc4c3SAl Viro if (IS_ERR(res))
1811ad6cc4c3SAl Viro return res;
1812ad6cc4c3SAl Viro }
1813ad6cc4c3SAl Viro if (*res == '/') {
1814ad6cc4c3SAl Viro error = nd_jump_root(nd);
1815ad6cc4c3SAl Viro if (unlikely(error))
1816ad6cc4c3SAl Viro return ERR_PTR(error);
1817ad6cc4c3SAl Viro while (unlikely(*++res == '/'))
1818ad6cc4c3SAl Viro ;
1819ad6cc4c3SAl Viro }
1820ad6cc4c3SAl Viro if (*res)
1821ad6cc4c3SAl Viro return res;
1822ad6cc4c3SAl Viro all_done: // pure jump
1823ad6cc4c3SAl Viro put_link(nd);
1824ad6cc4c3SAl Viro return NULL;
1825d63ff28fSAl Viro }
1826d63ff28fSAl Viro
18273ddcd056SLinus Torvalds /*
18283ddcd056SLinus Torvalds * Do we need to follow links? We _really_ want to be able
18293ddcd056SLinus Torvalds * to do this check without having to look at inode->i_op,
18303ddcd056SLinus Torvalds * so we keep a cache of "no, this doesn't need follow_link"
18313ddcd056SLinus Torvalds * for the common case.
183203fa86e9SAl Viro *
183303fa86e9SAl Viro * NOTE: dentry must be what nd->next_seq had been sampled from.
18343ddcd056SLinus Torvalds */
step_into(struct nameidata * nd,int flags,struct dentry * dentry)1835b0417d2cSAl Viro static const char *step_into(struct nameidata *nd, int flags,
1836a4f5b521SAl Viro struct dentry *dentry)
18373ddcd056SLinus Torvalds {
1838cbae4d12SAl Viro struct path path;
1839a4f5b521SAl Viro struct inode *inode;
18403bd8bc89SAl Viro int err = handle_mounts(nd, dentry, &path);
1841cbae4d12SAl Viro
1842cbae4d12SAl Viro if (err < 0)
1843b0417d2cSAl Viro return ERR_PTR(err);
18443bd8bc89SAl Viro inode = path.dentry->d_inode;
1845cbae4d12SAl Viro if (likely(!d_is_symlink(path.dentry)) ||
18468c4efe22SAl Viro ((flags & WALK_TRAILING) && !(nd->flags & LOOKUP_FOLLOW)) ||
1847aca2903eSAl Viro (flags & WALK_NOFOLLOW)) {
18488f64fb1cSAl Viro /* not a symlink or should not follow */
18493bd8bc89SAl Viro if (nd->flags & LOOKUP_RCU) {
18503bd8bc89SAl Viro if (read_seqcount_retry(&path.dentry->d_seq, nd->next_seq))
18513bd8bc89SAl Viro return ERR_PTR(-ECHILD);
18523bd8bc89SAl Viro if (unlikely(!inode))
18533bd8bc89SAl Viro return ERR_PTR(-ENOENT);
18543bd8bc89SAl Viro } else {
1855c99687a0SAl Viro dput(nd->path.dentry);
1856c99687a0SAl Viro if (nd->path.mnt != path.mnt)
1857c99687a0SAl Viro mntput(nd->path.mnt);
1858c99687a0SAl Viro }
1859c99687a0SAl Viro nd->path = path;
18608f64fb1cSAl Viro nd->inode = inode;
186103fa86e9SAl Viro nd->seq = nd->next_seq;
1862b0417d2cSAl Viro return NULL;
18638f64fb1cSAl Viro }
1864a7f77542SAl Viro if (nd->flags & LOOKUP_RCU) {
186584f0cd9eSAl Viro /* make sure that d_is_symlink above matches inode */
186603fa86e9SAl Viro if (read_seqcount_retry(&path.dentry->d_seq, nd->next_seq))
1867b0417d2cSAl Viro return ERR_PTR(-ECHILD);
186884f0cd9eSAl Viro } else {
186984f0cd9eSAl Viro if (path.mnt == nd->path.mnt)
187084f0cd9eSAl Viro mntget(path.mnt);
1871a7f77542SAl Viro }
187203fa86e9SAl Viro return pick_link(nd, &path, inode, flags);
18733ddcd056SLinus Torvalds }
18743ddcd056SLinus Torvalds
follow_dotdot_rcu(struct nameidata * nd)1875b16c001dSAl Viro static struct dentry *follow_dotdot_rcu(struct nameidata *nd)
1876957dd41dSAl Viro {
187712487f30SAl Viro struct dentry *parent, *old;
1878957dd41dSAl Viro
187912487f30SAl Viro if (path_equal(&nd->path, &nd->root))
188012487f30SAl Viro goto in_root;
188112487f30SAl Viro if (unlikely(nd->path.dentry == nd->path.mnt->mnt_root)) {
18827ef482faSAl Viro struct path path;
1883efe772d6SAl Viro unsigned seq;
18847ef482faSAl Viro if (!choose_mountpoint_rcu(real_mount(nd->path.mnt),
18857ef482faSAl Viro &nd->root, &path, &seq))
188612487f30SAl Viro goto in_root;
1887efe772d6SAl Viro if (unlikely(nd->flags & LOOKUP_NO_XDEV))
1888efe772d6SAl Viro return ERR_PTR(-ECHILD);
1889efe772d6SAl Viro nd->path = path;
1890efe772d6SAl Viro nd->inode = path.dentry->d_inode;
1891efe772d6SAl Viro nd->seq = seq;
189203fa86e9SAl Viro // makes sure that non-RCU pathwalk could reach this state
189382ef0698SAl Viro if (read_seqretry(&mount_lock, nd->m_seq))
1894efe772d6SAl Viro return ERR_PTR(-ECHILD);
1895efe772d6SAl Viro /* we know that mountpoint was pinned */
1896957dd41dSAl Viro }
189712487f30SAl Viro old = nd->path.dentry;
189812487f30SAl Viro parent = old->d_parent;
189903fa86e9SAl Viro nd->next_seq = read_seqcount_begin(&parent->d_seq);
190003fa86e9SAl Viro // makes sure that non-RCU pathwalk could reach this state
190182ef0698SAl Viro if (read_seqcount_retry(&old->d_seq, nd->seq))
190212487f30SAl Viro return ERR_PTR(-ECHILD);
190312487f30SAl Viro if (unlikely(!path_connected(nd->path.mnt, parent)))
190412487f30SAl Viro return ERR_PTR(-ECHILD);
190512487f30SAl Viro return parent;
190612487f30SAl Viro in_root:
190782ef0698SAl Viro if (read_seqretry(&mount_lock, nd->m_seq))
1908efe772d6SAl Viro return ERR_PTR(-ECHILD);
1909957dd41dSAl Viro if (unlikely(nd->flags & LOOKUP_BENEATH))
19107521f22bSAl Viro return ERR_PTR(-ECHILD);
191103fa86e9SAl Viro nd->next_seq = nd->seq;
191251c6546cSAl Viro return nd->path.dentry;
1913957dd41dSAl Viro }
1914957dd41dSAl Viro
follow_dotdot(struct nameidata * nd)1915b16c001dSAl Viro static struct dentry *follow_dotdot(struct nameidata *nd)
1916957dd41dSAl Viro {
191712487f30SAl Viro struct dentry *parent;
191812487f30SAl Viro
1919957dd41dSAl Viro if (path_equal(&nd->path, &nd->root))
192012487f30SAl Viro goto in_root;
192112487f30SAl Viro if (unlikely(nd->path.dentry == nd->path.mnt->mnt_root)) {
19222aa38470SAl Viro struct path path;
19232aa38470SAl Viro
19242aa38470SAl Viro if (!choose_mountpoint(real_mount(nd->path.mnt),
19252aa38470SAl Viro &nd->root, &path))
192612487f30SAl Viro goto in_root;
1927165200d6SAl Viro path_put(&nd->path);
1928165200d6SAl Viro nd->path = path;
19292aa38470SAl Viro nd->inode = path.dentry->d_inode;
1930165200d6SAl Viro if (unlikely(nd->flags & LOOKUP_NO_XDEV))
1931165200d6SAl Viro return ERR_PTR(-EXDEV);
193212487f30SAl Viro }
1933957dd41dSAl Viro /* rare case of legitimate dget_parent()... */
193412487f30SAl Viro parent = dget_parent(nd->path.dentry);
1935957dd41dSAl Viro if (unlikely(!path_connected(nd->path.mnt, parent))) {
1936957dd41dSAl Viro dput(parent);
19377521f22bSAl Viro return ERR_PTR(-ENOENT);
1938957dd41dSAl Viro }
1939c2df1968SAl Viro return parent;
194012487f30SAl Viro
194112487f30SAl Viro in_root:
1942957dd41dSAl Viro if (unlikely(nd->flags & LOOKUP_BENEATH))
19437521f22bSAl Viro return ERR_PTR(-EXDEV);
194451c6546cSAl Viro return dget(nd->path.dentry);
1945957dd41dSAl Viro }
1946957dd41dSAl Viro
handle_dots(struct nameidata * nd,int type)19477521f22bSAl Viro static const char *handle_dots(struct nameidata *nd, int type)
1948957dd41dSAl Viro {
1949957dd41dSAl Viro if (type == LAST_DOTDOT) {
19507521f22bSAl Viro const char *error = NULL;
1951c2df1968SAl Viro struct dentry *parent;
1952957dd41dSAl Viro
1953957dd41dSAl Viro if (!nd->root.mnt) {
19547521f22bSAl Viro error = ERR_PTR(set_root(nd));
1955957dd41dSAl Viro if (error)
1956957dd41dSAl Viro return error;
1957957dd41dSAl Viro }
1958957dd41dSAl Viro if (nd->flags & LOOKUP_RCU)
1959b16c001dSAl Viro parent = follow_dotdot_rcu(nd);
1960957dd41dSAl Viro else
1961b16c001dSAl Viro parent = follow_dotdot(nd);
1962c2df1968SAl Viro if (IS_ERR(parent))
1963c2df1968SAl Viro return ERR_CAST(parent);
1964a4f5b521SAl Viro error = step_into(nd, WALK_NOFOLLOW, parent);
1965c2df1968SAl Viro if (unlikely(error))
1966957dd41dSAl Viro return error;
1967957dd41dSAl Viro
1968957dd41dSAl Viro if (unlikely(nd->flags & LOOKUP_IS_SCOPED)) {
1969957dd41dSAl Viro /*
1970957dd41dSAl Viro * If there was a racing rename or mount along our
1971957dd41dSAl Viro * path, then we can't be sure that ".." hasn't jumped
1972957dd41dSAl Viro * above nd->root (and so userspace should retry or use
1973957dd41dSAl Viro * some fallback).
1974957dd41dSAl Viro */
1975957dd41dSAl Viro smp_rmb();
197682ef0698SAl Viro if (__read_seqcount_retry(&mount_lock.seqcount, nd->m_seq))
19777521f22bSAl Viro return ERR_PTR(-EAGAIN);
197882ef0698SAl Viro if (__read_seqcount_retry(&rename_lock.seqcount, nd->r_seq))
19797521f22bSAl Viro return ERR_PTR(-EAGAIN);
1980957dd41dSAl Viro }
1981957dd41dSAl Viro }
19827521f22bSAl Viro return NULL;
1983957dd41dSAl Viro }
1984957dd41dSAl Viro
walk_component(struct nameidata * nd,int flags)198592d27016SAl Viro static const char *walk_component(struct nameidata *nd, int flags)
1986ce57dfc1SAl Viro {
1987db3c9adeSAl Viro struct dentry *dentry;
1988ce57dfc1SAl Viro /*
1989ce57dfc1SAl Viro * "." and ".." are special - ".." especially so because it has
1990ce57dfc1SAl Viro * to be able to know about the current root directory and
1991ce57dfc1SAl Viro * parent relationships.
1992ce57dfc1SAl Viro */
19934693a547SAl Viro if (unlikely(nd->last_type != LAST_NORM)) {
19941c4ff1a8SAl Viro if (!(flags & WALK_MORE) && nd->depth)
19954693a547SAl Viro put_link(nd);
19967521f22bSAl Viro return handle_dots(nd, nd->last_type);
19974693a547SAl Viro }
19984cb64024SAl Viro dentry = lookup_fast(nd);
199920e34357SAl Viro if (IS_ERR(dentry))
200092d27016SAl Viro return ERR_CAST(dentry);
200120e34357SAl Viro if (unlikely(!dentry)) {
2002db3c9adeSAl Viro dentry = lookup_slow(&nd->last, nd->path.dentry, nd->flags);
2003db3c9adeSAl Viro if (IS_ERR(dentry))
200492d27016SAl Viro return ERR_CAST(dentry);
200520e34357SAl Viro }
200656676ec3SAl Viro if (!(flags & WALK_MORE) && nd->depth)
200756676ec3SAl Viro put_link(nd);
2008a4f5b521SAl Viro return step_into(nd, flags, dentry);
2009ce57dfc1SAl Viro }
2010ce57dfc1SAl Viro
20111da177e4SLinus Torvalds /*
2012bfcfaa77SLinus Torvalds * We can do the critical dentry name comparison and hashing
2013bfcfaa77SLinus Torvalds * operations one word at a time, but we are limited to:
2014bfcfaa77SLinus Torvalds *
2015bfcfaa77SLinus Torvalds * - Architectures with fast unaligned word accesses. We could
2016bfcfaa77SLinus Torvalds * do a "get_unaligned()" if this helps and is sufficiently
2017bfcfaa77SLinus Torvalds * fast.
2018bfcfaa77SLinus Torvalds *
2019bfcfaa77SLinus Torvalds * - non-CONFIG_DEBUG_PAGEALLOC configurations (so that we
2020bfcfaa77SLinus Torvalds * do not trap on the (extremely unlikely) case of a page
2021bfcfaa77SLinus Torvalds * crossing operation.
2022bfcfaa77SLinus Torvalds *
2023bfcfaa77SLinus Torvalds * - Furthermore, we need an efficient 64-bit compile for the
2024bfcfaa77SLinus Torvalds * 64-bit case in order to generate the "number of bytes in
2025bfcfaa77SLinus Torvalds * the final mask". Again, that could be replaced with a
2026bfcfaa77SLinus Torvalds * efficient population count instruction or similar.
2027bfcfaa77SLinus Torvalds */
2028bfcfaa77SLinus Torvalds #ifdef CONFIG_DCACHE_WORD_ACCESS
2029bfcfaa77SLinus Torvalds
2030f68e556eSLinus Torvalds #include <asm/word-at-a-time.h>
2031bfcfaa77SLinus Torvalds
2032468a9428SGeorge Spelvin #ifdef HASH_MIX
2033bfcfaa77SLinus Torvalds
2034468a9428SGeorge Spelvin /* Architecture provides HASH_MIX and fold_hash() in <asm/hash.h> */
2035468a9428SGeorge Spelvin
2036468a9428SGeorge Spelvin #elif defined(CONFIG_64BIT)
20372a18da7aSGeorge Spelvin /*
20382a18da7aSGeorge Spelvin * Register pressure in the mixing function is an issue, particularly
20392a18da7aSGeorge Spelvin * on 32-bit x86, but almost any function requires one state value and
20402a18da7aSGeorge Spelvin * one temporary. Instead, use a function designed for two state values
20412a18da7aSGeorge Spelvin * and no temporaries.
20422a18da7aSGeorge Spelvin *
20432a18da7aSGeorge Spelvin * This function cannot create a collision in only two iterations, so
20442a18da7aSGeorge Spelvin * we have two iterations to achieve avalanche. In those two iterations,
20452a18da7aSGeorge Spelvin * we have six layers of mixing, which is enough to spread one bit's
20462a18da7aSGeorge Spelvin * influence out to 2^6 = 64 state bits.
20472a18da7aSGeorge Spelvin *
20482a18da7aSGeorge Spelvin * Rotate constants are scored by considering either 64 one-bit input
20492a18da7aSGeorge Spelvin * deltas or 64*63/2 = 2016 two-bit input deltas, and finding the
20502a18da7aSGeorge Spelvin * probability of that delta causing a change to each of the 128 output
20512a18da7aSGeorge Spelvin * bits, using a sample of random initial states.
20522a18da7aSGeorge Spelvin *
20532a18da7aSGeorge Spelvin * The Shannon entropy of the computed probabilities is then summed
20542a18da7aSGeorge Spelvin * to produce a score. Ideally, any input change has a 50% chance of
20552a18da7aSGeorge Spelvin * toggling any given output bit.
20562a18da7aSGeorge Spelvin *
20572a18da7aSGeorge Spelvin * Mixing scores (in bits) for (12,45):
20582a18da7aSGeorge Spelvin * Input delta: 1-bit 2-bit
20592a18da7aSGeorge Spelvin * 1 round: 713.3 42542.6
20602a18da7aSGeorge Spelvin * 2 rounds: 2753.7 140389.8
20612a18da7aSGeorge Spelvin * 3 rounds: 5954.1 233458.2
20622a18da7aSGeorge Spelvin * 4 rounds: 7862.6 256672.2
20632a18da7aSGeorge Spelvin * Perfect: 8192 258048
20642a18da7aSGeorge Spelvin * (64*128) (64*63/2 * 128)
20652a18da7aSGeorge Spelvin */
20662a18da7aSGeorge Spelvin #define HASH_MIX(x, y, a) \
20672a18da7aSGeorge Spelvin ( x ^= (a), \
20682a18da7aSGeorge Spelvin y ^= x, x = rol64(x,12),\
20692a18da7aSGeorge Spelvin x += y, y = rol64(y,45),\
20702a18da7aSGeorge Spelvin y *= 9 )
2071bfcfaa77SLinus Torvalds
20720fed3ac8SGeorge Spelvin /*
20732a18da7aSGeorge Spelvin * Fold two longs into one 32-bit hash value. This must be fast, but
20742a18da7aSGeorge Spelvin * latency isn't quite as critical, as there is a fair bit of additional
20752a18da7aSGeorge Spelvin * work done before the hash value is used.
20760fed3ac8SGeorge Spelvin */
fold_hash(unsigned long x,unsigned long y)20772a18da7aSGeorge Spelvin static inline unsigned int fold_hash(unsigned long x, unsigned long y)
20780fed3ac8SGeorge Spelvin {
20792a18da7aSGeorge Spelvin y ^= x * GOLDEN_RATIO_64;
20802a18da7aSGeorge Spelvin y *= GOLDEN_RATIO_64;
20812a18da7aSGeorge Spelvin return y >> 32;
20820fed3ac8SGeorge Spelvin }
20830fed3ac8SGeorge Spelvin
2084bfcfaa77SLinus Torvalds #else /* 32-bit case */
2085bfcfaa77SLinus Torvalds
20862a18da7aSGeorge Spelvin /*
20872a18da7aSGeorge Spelvin * Mixing scores (in bits) for (7,20):
20882a18da7aSGeorge Spelvin * Input delta: 1-bit 2-bit
20892a18da7aSGeorge Spelvin * 1 round: 330.3 9201.6
20902a18da7aSGeorge Spelvin * 2 rounds: 1246.4 25475.4
20912a18da7aSGeorge Spelvin * 3 rounds: 1907.1 31295.1
20922a18da7aSGeorge Spelvin * 4 rounds: 2042.3 31718.6
20932a18da7aSGeorge Spelvin * Perfect: 2048 31744
20942a18da7aSGeorge Spelvin * (32*64) (32*31/2 * 64)
20952a18da7aSGeorge Spelvin */
20962a18da7aSGeorge Spelvin #define HASH_MIX(x, y, a) \
20972a18da7aSGeorge Spelvin ( x ^= (a), \
20982a18da7aSGeorge Spelvin y ^= x, x = rol32(x, 7),\
20992a18da7aSGeorge Spelvin x += y, y = rol32(y,20),\
21002a18da7aSGeorge Spelvin y *= 9 )
2101bfcfaa77SLinus Torvalds
fold_hash(unsigned long x,unsigned long y)21022a18da7aSGeorge Spelvin static inline unsigned int fold_hash(unsigned long x, unsigned long y)
21030fed3ac8SGeorge Spelvin {
21042a18da7aSGeorge Spelvin /* Use arch-optimized multiply if one exists */
21052a18da7aSGeorge Spelvin return __hash_32(y ^ __hash_32(x));
21060fed3ac8SGeorge Spelvin }
21070fed3ac8SGeorge Spelvin
2108bfcfaa77SLinus Torvalds #endif
2109bfcfaa77SLinus Torvalds
21102a18da7aSGeorge Spelvin /*
21112a18da7aSGeorge Spelvin * Return the hash of a string of known length. This is carfully
21122a18da7aSGeorge Spelvin * designed to match hash_name(), which is the more critical function.
21132a18da7aSGeorge Spelvin * In particular, we must end by hashing a final word containing 0..7
21142a18da7aSGeorge Spelvin * payload bytes, to match the way that hash_name() iterates until it
21152a18da7aSGeorge Spelvin * finds the delimiter after the name.
21162a18da7aSGeorge Spelvin */
full_name_hash(const void * salt,const char * name,unsigned int len)21178387ff25SLinus Torvalds unsigned int full_name_hash(const void *salt, const char *name, unsigned int len)
2118bfcfaa77SLinus Torvalds {
21198387ff25SLinus Torvalds unsigned long a, x = 0, y = (unsigned long)salt;
2120bfcfaa77SLinus Torvalds
2121bfcfaa77SLinus Torvalds for (;;) {
2122fcfd2fbfSGeorge Spelvin if (!len)
2123fcfd2fbfSGeorge Spelvin goto done;
2124e419b4ccSLinus Torvalds a = load_unaligned_zeropad(name);
2125bfcfaa77SLinus Torvalds if (len < sizeof(unsigned long))
2126bfcfaa77SLinus Torvalds break;
21272a18da7aSGeorge Spelvin HASH_MIX(x, y, a);
2128bfcfaa77SLinus Torvalds name += sizeof(unsigned long);
2129bfcfaa77SLinus Torvalds len -= sizeof(unsigned long);
2130bfcfaa77SLinus Torvalds }
21312a18da7aSGeorge Spelvin x ^= a & bytemask_from_count(len);
2132bfcfaa77SLinus Torvalds done:
21332a18da7aSGeorge Spelvin return fold_hash(x, y);
2134bfcfaa77SLinus Torvalds }
2135bfcfaa77SLinus Torvalds EXPORT_SYMBOL(full_name_hash);
2136bfcfaa77SLinus Torvalds
2137fcfd2fbfSGeorge Spelvin /* Return the "hash_len" (hash and length) of a null-terminated string */
hashlen_string(const void * salt,const char * name)21388387ff25SLinus Torvalds u64 hashlen_string(const void *salt, const char *name)
2139fcfd2fbfSGeorge Spelvin {
21408387ff25SLinus Torvalds unsigned long a = 0, x = 0, y = (unsigned long)salt;
21418387ff25SLinus Torvalds unsigned long adata, mask, len;
2142fcfd2fbfSGeorge Spelvin const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
2143fcfd2fbfSGeorge Spelvin
21448387ff25SLinus Torvalds len = 0;
21458387ff25SLinus Torvalds goto inside;
21468387ff25SLinus Torvalds
2147fcfd2fbfSGeorge Spelvin do {
21482a18da7aSGeorge Spelvin HASH_MIX(x, y, a);
2149fcfd2fbfSGeorge Spelvin len += sizeof(unsigned long);
21508387ff25SLinus Torvalds inside:
2151fcfd2fbfSGeorge Spelvin a = load_unaligned_zeropad(name+len);
2152fcfd2fbfSGeorge Spelvin } while (!has_zero(a, &adata, &constants));
2153fcfd2fbfSGeorge Spelvin
2154fcfd2fbfSGeorge Spelvin adata = prep_zero_mask(a, adata, &constants);
2155fcfd2fbfSGeorge Spelvin mask = create_zero_mask(adata);
21562a18da7aSGeorge Spelvin x ^= a & zero_bytemask(mask);
2157fcfd2fbfSGeorge Spelvin
21582a18da7aSGeorge Spelvin return hashlen_create(fold_hash(x, y), len + find_zero(mask));
2159fcfd2fbfSGeorge Spelvin }
2160fcfd2fbfSGeorge Spelvin EXPORT_SYMBOL(hashlen_string);
2161fcfd2fbfSGeorge Spelvin
2162bfcfaa77SLinus Torvalds /*
2163bfcfaa77SLinus Torvalds * Calculate the length and hash of the path component, and
2164d6bb3e90SLinus Torvalds * return the "hash_len" as the result.
2165bfcfaa77SLinus Torvalds */
hash_name(const void * salt,const char * name)21668387ff25SLinus Torvalds static inline u64 hash_name(const void *salt, const char *name)
2167bfcfaa77SLinus Torvalds {
21688387ff25SLinus Torvalds unsigned long a = 0, b, x = 0, y = (unsigned long)salt;
21698387ff25SLinus Torvalds unsigned long adata, bdata, mask, len;
217036126f8fSLinus Torvalds const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
2171bfcfaa77SLinus Torvalds
21728387ff25SLinus Torvalds len = 0;
21738387ff25SLinus Torvalds goto inside;
21748387ff25SLinus Torvalds
2175bfcfaa77SLinus Torvalds do {
21762a18da7aSGeorge Spelvin HASH_MIX(x, y, a);
2177bfcfaa77SLinus Torvalds len += sizeof(unsigned long);
21788387ff25SLinus Torvalds inside:
2179e419b4ccSLinus Torvalds a = load_unaligned_zeropad(name+len);
218036126f8fSLinus Torvalds b = a ^ REPEAT_BYTE('/');
218136126f8fSLinus Torvalds } while (!(has_zero(a, &adata, &constants) | has_zero(b, &bdata, &constants)));
2182bfcfaa77SLinus Torvalds
218336126f8fSLinus Torvalds adata = prep_zero_mask(a, adata, &constants);
218436126f8fSLinus Torvalds bdata = prep_zero_mask(b, bdata, &constants);
218536126f8fSLinus Torvalds mask = create_zero_mask(adata | bdata);
21862a18da7aSGeorge Spelvin x ^= a & zero_bytemask(mask);
218736126f8fSLinus Torvalds
21882a18da7aSGeorge Spelvin return hashlen_create(fold_hash(x, y), len + find_zero(mask));
2189bfcfaa77SLinus Torvalds }
2190bfcfaa77SLinus Torvalds
21912a18da7aSGeorge Spelvin #else /* !CONFIG_DCACHE_WORD_ACCESS: Slow, byte-at-a-time version */
2192bfcfaa77SLinus Torvalds
2193fcfd2fbfSGeorge Spelvin /* Return the hash of a string of known length */
full_name_hash(const void * salt,const char * name,unsigned int len)21948387ff25SLinus Torvalds unsigned int full_name_hash(const void *salt, const char *name, unsigned int len)
21950145acc2SLinus Torvalds {
21968387ff25SLinus Torvalds unsigned long hash = init_name_hash(salt);
21970145acc2SLinus Torvalds while (len--)
2198fcfd2fbfSGeorge Spelvin hash = partial_name_hash((unsigned char)*name++, hash);
21990145acc2SLinus Torvalds return end_name_hash(hash);
22000145acc2SLinus Torvalds }
2201ae942ae7SLinus Torvalds EXPORT_SYMBOL(full_name_hash);
22020145acc2SLinus Torvalds
2203fcfd2fbfSGeorge Spelvin /* Return the "hash_len" (hash and length) of a null-terminated string */
hashlen_string(const void * salt,const char * name)22048387ff25SLinus Torvalds u64 hashlen_string(const void *salt, const char *name)
2205fcfd2fbfSGeorge Spelvin {
22068387ff25SLinus Torvalds unsigned long hash = init_name_hash(salt);
2207fcfd2fbfSGeorge Spelvin unsigned long len = 0, c;
2208fcfd2fbfSGeorge Spelvin
2209fcfd2fbfSGeorge Spelvin c = (unsigned char)*name;
2210e0ab7af9SGeorge Spelvin while (c) {
2211fcfd2fbfSGeorge Spelvin len++;
2212fcfd2fbfSGeorge Spelvin hash = partial_name_hash(c, hash);
2213fcfd2fbfSGeorge Spelvin c = (unsigned char)name[len];
2214e0ab7af9SGeorge Spelvin }
2215fcfd2fbfSGeorge Spelvin return hashlen_create(end_name_hash(hash), len);
2216fcfd2fbfSGeorge Spelvin }
2217f2a031b6SGeorge Spelvin EXPORT_SYMBOL(hashlen_string);
2218fcfd2fbfSGeorge Spelvin
22193ddcd056SLinus Torvalds /*
2220200e9ef7SLinus Torvalds * We know there's a real path component here of at least
2221200e9ef7SLinus Torvalds * one character.
2222200e9ef7SLinus Torvalds */
hash_name(const void * salt,const char * name)22238387ff25SLinus Torvalds static inline u64 hash_name(const void *salt, const char *name)
2224200e9ef7SLinus Torvalds {
22258387ff25SLinus Torvalds unsigned long hash = init_name_hash(salt);
2226200e9ef7SLinus Torvalds unsigned long len = 0, c;
2227200e9ef7SLinus Torvalds
2228200e9ef7SLinus Torvalds c = (unsigned char)*name;
2229200e9ef7SLinus Torvalds do {
2230200e9ef7SLinus Torvalds len++;
2231200e9ef7SLinus Torvalds hash = partial_name_hash(c, hash);
2232200e9ef7SLinus Torvalds c = (unsigned char)name[len];
2233200e9ef7SLinus Torvalds } while (c && c != '/');
2234d6bb3e90SLinus Torvalds return hashlen_create(end_name_hash(hash), len);
2235200e9ef7SLinus Torvalds }
2236200e9ef7SLinus Torvalds
2237bfcfaa77SLinus Torvalds #endif
2238bfcfaa77SLinus Torvalds
2239200e9ef7SLinus Torvalds /*
22401da177e4SLinus Torvalds * Name resolution.
2241ea3834d9SPrasanna Meda * This is the basic name resolution function, turning a pathname into
2242ea3834d9SPrasanna Meda * the final dentry. We expect 'base' to be positive and a directory.
22431da177e4SLinus Torvalds *
2244ea3834d9SPrasanna Meda * Returns 0 and nd will have valid dentry and mnt on success.
2245ea3834d9SPrasanna Meda * Returns error and drops reference to input namei data on failure.
22461da177e4SLinus Torvalds */
link_path_walk(const char * name,struct nameidata * nd)22476de88d72SAl Viro static int link_path_walk(const char *name, struct nameidata *nd)
22481da177e4SLinus Torvalds {
2249d8d4611aSAl Viro int depth = 0; // depth <= nd->depth
22501da177e4SLinus Torvalds int err;
22511da177e4SLinus Torvalds
2252b4c03536SAl Viro nd->last_type = LAST_ROOT;
2253c108837eSAl Viro nd->flags |= LOOKUP_PARENT;
22549b5858e9SAl Viro if (IS_ERR(name))
22559b5858e9SAl Viro return PTR_ERR(name);
22561da177e4SLinus Torvalds while (*name=='/')
22571da177e4SLinus Torvalds name++;
22581a97d899SAl Viro if (!*name) {
22591a97d899SAl Viro nd->dir_mode = 0; // short-circuit the 'hardening' idiocy
22609e18f10aSAl Viro return 0;
22611a97d899SAl Viro }
22621da177e4SLinus Torvalds
22631da177e4SLinus Torvalds /* At this point we know we have a real path component. */
22641da177e4SLinus Torvalds for(;;) {
22654609e1f1SChristian Brauner struct mnt_idmap *idmap;
226692d27016SAl Viro const char *link;
2267d6bb3e90SLinus Torvalds u64 hash_len;
2268fe479a58SAl Viro int type;
22691da177e4SLinus Torvalds
22704609e1f1SChristian Brauner idmap = mnt_idmap(nd->path.mnt);
22714609e1f1SChristian Brauner err = may_lookup(idmap, nd);
22721da177e4SLinus Torvalds if (err)
22733595e234SAl Viro return err;
22741da177e4SLinus Torvalds
22758387ff25SLinus Torvalds hash_len = hash_name(nd->path.dentry, name);
22761da177e4SLinus Torvalds
2277fe479a58SAl Viro type = LAST_NORM;
2278d6bb3e90SLinus Torvalds if (name[0] == '.') switch (hashlen_len(hash_len)) {
2279fe479a58SAl Viro case 2:
2280200e9ef7SLinus Torvalds if (name[1] == '.') {
2281fe479a58SAl Viro type = LAST_DOTDOT;
2282bcba1e7dSAl Viro nd->state |= ND_JUMPED;
228316c2cd71SAl Viro }
2284fe479a58SAl Viro break;
2285fe479a58SAl Viro case 1:
2286fe479a58SAl Viro type = LAST_DOT;
2287fe479a58SAl Viro }
22885a202bcdSAl Viro if (likely(type == LAST_NORM)) {
22895a202bcdSAl Viro struct dentry *parent = nd->path.dentry;
2290bcba1e7dSAl Viro nd->state &= ~ND_JUMPED;
22915a202bcdSAl Viro if (unlikely(parent->d_flags & DCACHE_OP_HASH)) {
2292a060dc50SJames Hogan struct qstr this = { { .hash_len = hash_len }, .name = name };
2293da53be12SLinus Torvalds err = parent->d_op->d_hash(parent, &this);
22945a202bcdSAl Viro if (err < 0)
22953595e234SAl Viro return err;
2296d6bb3e90SLinus Torvalds hash_len = this.hash_len;
2297d6bb3e90SLinus Torvalds name = this.name;
22985a202bcdSAl Viro }
22995a202bcdSAl Viro }
2300fe479a58SAl Viro
2301d6bb3e90SLinus Torvalds nd->last.hash_len = hash_len;
2302d6bb3e90SLinus Torvalds nd->last.name = name;
23035f4a6a69SAl Viro nd->last_type = type;
23045f4a6a69SAl Viro
2305d6bb3e90SLinus Torvalds name += hashlen_len(hash_len);
2306d6bb3e90SLinus Torvalds if (!*name)
2307bdf6cbf1SAl Viro goto OK;
2308200e9ef7SLinus Torvalds /*
2309200e9ef7SLinus Torvalds * If it wasn't NUL, we know it was '/'. Skip that
2310200e9ef7SLinus Torvalds * slash, and continue until no more slashes.
2311200e9ef7SLinus Torvalds */
2312200e9ef7SLinus Torvalds do {
2313d6bb3e90SLinus Torvalds name++;
2314d6bb3e90SLinus Torvalds } while (unlikely(*name == '/'));
23158620c238SAl Viro if (unlikely(!*name)) {
23168620c238SAl Viro OK:
2317d8d4611aSAl Viro /* pathname or trailing symlink, done */
2318c108837eSAl Viro if (!depth) {
2319e67fe633SChristian Brauner nd->dir_vfsuid = i_uid_into_vfsuid(idmap, nd->inode);
23200f705953SAl Viro nd->dir_mode = nd->inode->i_mode;
2321c108837eSAl Viro nd->flags &= ~LOOKUP_PARENT;
23228620c238SAl Viro return 0;
2323c108837eSAl Viro }
23248620c238SAl Viro /* last component of nested symlink */
2325d8d4611aSAl Viro name = nd->stack[--depth].name;
23268c4efe22SAl Viro link = walk_component(nd, 0);
23271c4ff1a8SAl Viro } else {
23281c4ff1a8SAl Viro /* not the last component */
23298c4efe22SAl Viro link = walk_component(nd, WALK_MORE);
23308620c238SAl Viro }
233192d27016SAl Viro if (unlikely(link)) {
233292d27016SAl Viro if (IS_ERR(link))
233392d27016SAl Viro return PTR_ERR(link);
233492d27016SAl Viro /* a symlink to follow */
2335d8d4611aSAl Viro nd->stack[depth++].name = name;
233692d27016SAl Viro name = link;
23379e18f10aSAl Viro continue;
233848c8b0c5SAl Viro }
233997242f99SAl Viro if (unlikely(!d_can_lookup(nd->path.dentry))) {
234097242f99SAl Viro if (nd->flags & LOOKUP_RCU) {
2341e36cffedSJens Axboe if (!try_to_unlazy(nd))
234297242f99SAl Viro return -ECHILD;
234397242f99SAl Viro }
23443595e234SAl Viro return -ENOTDIR;
23455f4a6a69SAl Viro }
2346ce57dfc1SAl Viro }
234797242f99SAl Viro }
23481da177e4SLinus Torvalds
2349edc2b1daSAl Viro /* must be paired with terminate_walk() */
path_init(struct nameidata * nd,unsigned flags)2350c8a53ee5SAl Viro static const char *path_init(struct nameidata *nd, unsigned flags)
235131e6b01fSNick Piggin {
2352740a1678SAleksa Sarai int error;
2353c8a53ee5SAl Viro const char *s = nd->name->name;
235431e6b01fSNick Piggin
23556c6ec2b0SJens Axboe /* LOOKUP_CACHED requires RCU, ask caller to retry */
23566c6ec2b0SJens Axboe if ((flags & (LOOKUP_RCU | LOOKUP_CACHED)) == LOOKUP_CACHED)
23576c6ec2b0SJens Axboe return ERR_PTR(-EAGAIN);
23586c6ec2b0SJens Axboe
2359c0eb027eSLinus Torvalds if (!*s)
2360c0eb027eSLinus Torvalds flags &= ~LOOKUP_RCU;
2361edc2b1daSAl Viro if (flags & LOOKUP_RCU)
2362edc2b1daSAl Viro rcu_read_lock();
236303fa86e9SAl Viro else
236403fa86e9SAl Viro nd->seq = nd->next_seq = 0;
2365c0eb027eSLinus Torvalds
2366bcba1e7dSAl Viro nd->flags = flags;
2367bcba1e7dSAl Viro nd->state |= ND_JUMPED;
2368ab87f9a5SAleksa Sarai
2369ab87f9a5SAleksa Sarai nd->m_seq = __read_seqcount_begin(&mount_lock.seqcount);
2370ab87f9a5SAleksa Sarai nd->r_seq = __read_seqcount_begin(&rename_lock.seqcount);
2371ab87f9a5SAleksa Sarai smp_rmb();
2372ab87f9a5SAleksa Sarai
2373bcba1e7dSAl Viro if (nd->state & ND_ROOT_PRESET) {
2374b18825a7SDavid Howells struct dentry *root = nd->root.dentry;
2375b18825a7SDavid Howells struct inode *inode = root->d_inode;
237693893862SAl Viro if (*s && unlikely(!d_can_lookup(root)))
2377368ee9baSAl Viro return ERR_PTR(-ENOTDIR);
23785b6ca027SAl Viro nd->path = nd->root;
23795b6ca027SAl Viro nd->inode = inode;
23805b6ca027SAl Viro if (flags & LOOKUP_RCU) {
2381ab87f9a5SAleksa Sarai nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
23828f47a016SAl Viro nd->root_seq = nd->seq;
23835b6ca027SAl Viro } else {
23845b6ca027SAl Viro path_get(&nd->path);
23855b6ca027SAl Viro }
2386368ee9baSAl Viro return s;
23875b6ca027SAl Viro }
23885b6ca027SAl Viro
238931e6b01fSNick Piggin nd->root.mnt = NULL;
239031e6b01fSNick Piggin
23918db52c7eSAleksa Sarai /* Absolute pathname -- fetch the root (LOOKUP_IN_ROOT uses nd->dfd). */
23928db52c7eSAleksa Sarai if (*s == '/' && !(flags & LOOKUP_IN_ROOT)) {
2393740a1678SAleksa Sarai error = nd_jump_root(nd);
2394740a1678SAleksa Sarai if (unlikely(error))
2395740a1678SAleksa Sarai return ERR_PTR(error);
2396ef55d917SAl Viro return s;
23978db52c7eSAleksa Sarai }
23988db52c7eSAleksa Sarai
23998db52c7eSAleksa Sarai /* Relative pathname -- get the starting-point it is relative to. */
24008db52c7eSAleksa Sarai if (nd->dfd == AT_FDCWD) {
2401e41f7d4eSAl Viro if (flags & LOOKUP_RCU) {
240231e6b01fSNick Piggin struct fs_struct *fs = current->fs;
2403c28cc364SNick Piggin unsigned seq;
240431e6b01fSNick Piggin
2405c28cc364SNick Piggin do {
2406c28cc364SNick Piggin seq = read_seqcount_begin(&fs->seq);
240731e6b01fSNick Piggin nd->path = fs->pwd;
2408ef55d917SAl Viro nd->inode = nd->path.dentry->d_inode;
2409c28cc364SNick Piggin nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
2410c28cc364SNick Piggin } while (read_seqcount_retry(&fs->seq, seq));
2411e41f7d4eSAl Viro } else {
2412e41f7d4eSAl Viro get_fs_pwd(current->fs, &nd->path);
2413ef55d917SAl Viro nd->inode = nd->path.dentry->d_inode;
2414e41f7d4eSAl Viro }
241531e6b01fSNick Piggin } else {
2416582aa64aSJeff Layton /* Caller must check execute permissions on the starting path component */
2417c8a53ee5SAl Viro struct fd f = fdget_raw(nd->dfd);
241831e6b01fSNick Piggin struct dentry *dentry;
241931e6b01fSNick Piggin
24202903ff01SAl Viro if (!f.file)
2421368ee9baSAl Viro return ERR_PTR(-EBADF);
242231e6b01fSNick Piggin
24232903ff01SAl Viro dentry = f.file->f_path.dentry;
242431e6b01fSNick Piggin
2425edc2b1daSAl Viro if (*s && unlikely(!d_can_lookup(dentry))) {
24262903ff01SAl Viro fdput(f);
2427368ee9baSAl Viro return ERR_PTR(-ENOTDIR);
2428f52e0c11SAl Viro }
24292903ff01SAl Viro
24302903ff01SAl Viro nd->path = f.file->f_path;
2431e41f7d4eSAl Viro if (flags & LOOKUP_RCU) {
243234a26b99SAl Viro nd->inode = nd->path.dentry->d_inode;
243334a26b99SAl Viro nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
24345590ff0dSUlrich Drepper } else {
24352903ff01SAl Viro path_get(&nd->path);
243634a26b99SAl Viro nd->inode = nd->path.dentry->d_inode;
24371da177e4SLinus Torvalds }
243834a26b99SAl Viro fdput(f);
2439e41f7d4eSAl Viro }
24408db52c7eSAleksa Sarai
2441adb21d2bSAleksa Sarai /* For scoped-lookups we need to set the root to the dirfd as well. */
2442adb21d2bSAleksa Sarai if (flags & LOOKUP_IS_SCOPED) {
2443adb21d2bSAleksa Sarai nd->root = nd->path;
2444adb21d2bSAleksa Sarai if (flags & LOOKUP_RCU) {
2445adb21d2bSAleksa Sarai nd->root_seq = nd->seq;
2446adb21d2bSAleksa Sarai } else {
2447adb21d2bSAleksa Sarai path_get(&nd->root);
2448bcba1e7dSAl Viro nd->state |= ND_ROOT_GRABBED;
2449adb21d2bSAleksa Sarai }
2450adb21d2bSAleksa Sarai }
2451adb21d2bSAleksa Sarai return s;
24529b4a9b14SAl Viro }
24539b4a9b14SAl Viro
lookup_last(struct nameidata * nd)24541ccac622SAl Viro static inline const char *lookup_last(struct nameidata *nd)
245595fa25d9SAl Viro {
2456bd92d7feSAl Viro if (nd->last_type == LAST_NORM && nd->last.name[nd->last.len])
2457bd92d7feSAl Viro nd->flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
2458bd92d7feSAl Viro
2459c108837eSAl Viro return walk_component(nd, WALK_TRAILING);
2460bd92d7feSAl Viro }
2461bd92d7feSAl Viro
handle_lookup_down(struct nameidata * nd)24624f757f3cSAl Viro static int handle_lookup_down(struct nameidata *nd)
24634f757f3cSAl Viro {
2464c153007bSAl Viro if (!(nd->flags & LOOKUP_RCU))
2465db3c9adeSAl Viro dget(nd->path.dentry);
246603fa86e9SAl Viro nd->next_seq = nd->seq;
2467a4f5b521SAl Viro return PTR_ERR(step_into(nd, WALK_NOFOLLOW, nd->path.dentry));
24684f757f3cSAl Viro }
24694f757f3cSAl Viro
24709b4a9b14SAl Viro /* Returns 0 and nd will be valid on success; Retuns error, otherwise. */
path_lookupat(struct nameidata * nd,unsigned flags,struct path * path)2471c8a53ee5SAl Viro static int path_lookupat(struct nameidata *nd, unsigned flags, struct path *path)
24729b4a9b14SAl Viro {
2473c8a53ee5SAl Viro const char *s = path_init(nd, flags);
2474bd92d7feSAl Viro int err;
247531e6b01fSNick Piggin
24769b5858e9SAl Viro if (unlikely(flags & LOOKUP_DOWN) && !IS_ERR(s)) {
24774f757f3cSAl Viro err = handle_lookup_down(nd);
24785f336e72SAl Viro if (unlikely(err < 0))
24795f336e72SAl Viro s = ERR_PTR(err);
24804f757f3cSAl Viro }
24814f757f3cSAl Viro
24821ccac622SAl Viro while (!(err = link_path_walk(s, nd)) &&
24831ccac622SAl Viro (s = lookup_last(nd)) != NULL)
24841ccac622SAl Viro ;
24854f0ed93fSAl Viro if (!err && unlikely(nd->flags & LOOKUP_MOUNTPOINT)) {
24864f0ed93fSAl Viro err = handle_lookup_down(nd);
2487bcba1e7dSAl Viro nd->state &= ~ND_JUMPED; // no d_weak_revalidate(), please...
24884f0ed93fSAl Viro }
24899f1fafeeSAl Viro if (!err)
24909f1fafeeSAl Viro err = complete_walk(nd);
2491bd92d7feSAl Viro
2492deb106c6SAl Viro if (!err && nd->flags & LOOKUP_DIRECTORY)
2493deb106c6SAl Viro if (!d_can_lookup(nd->path.dentry))
2494bd23a539SAl Viro err = -ENOTDIR;
2495625b6d10SAl Viro if (!err) {
2496625b6d10SAl Viro *path = nd->path;
2497625b6d10SAl Viro nd->path.mnt = NULL;
2498625b6d10SAl Viro nd->path.dentry = NULL;
2499625b6d10SAl Viro }
2500deb106c6SAl Viro terminate_walk(nd);
2501bd92d7feSAl Viro return err;
250231e6b01fSNick Piggin }
250331e6b01fSNick Piggin
filename_lookup(int dfd,struct filename * name,unsigned flags,struct path * path,struct path * root)2504794ebceaSStephen Brennan int filename_lookup(int dfd, struct filename *name, unsigned flags,
25059ad1aaa6SAl Viro struct path *path, struct path *root)
2506873f1eedSJeff Layton {
2507894bc8c4SAl Viro int retval;
25089883d185SAl Viro struct nameidata nd;
2509abc9f5beSAl Viro if (IS_ERR(name))
2510abc9f5beSAl Viro return PTR_ERR(name);
251106422964SAl Viro set_nameidata(&nd, dfd, name, root);
2512c8a53ee5SAl Viro retval = path_lookupat(&nd, flags | LOOKUP_RCU, path);
2513873f1eedSJeff Layton if (unlikely(retval == -ECHILD))
2514c8a53ee5SAl Viro retval = path_lookupat(&nd, flags, path);
2515873f1eedSJeff Layton if (unlikely(retval == -ESTALE))
2516c8a53ee5SAl Viro retval = path_lookupat(&nd, flags | LOOKUP_REVAL, path);
2517873f1eedSJeff Layton
2518873f1eedSJeff Layton if (likely(!retval))
2519161aff1dSAl Viro audit_inode(name, path->dentry,
2520161aff1dSAl Viro flags & LOOKUP_MOUNTPOINT ? AUDIT_INODE_NOEVAL : 0);
25219883d185SAl Viro restore_nameidata();
2522020250f3SDmitry Kadashev return retval;
2523020250f3SDmitry Kadashev }
2524020250f3SDmitry Kadashev
25258bcb77faSAl Viro /* Returns 0 and nd will be valid on success; Retuns error, otherwise. */
path_parentat(struct nameidata * nd,unsigned flags,struct path * parent)2526c8a53ee5SAl Viro static int path_parentat(struct nameidata *nd, unsigned flags,
2527391172c4SAl Viro struct path *parent)
25288bcb77faSAl Viro {
2529c8a53ee5SAl Viro const char *s = path_init(nd, flags);
25309b5858e9SAl Viro int err = link_path_walk(s, nd);
25318bcb77faSAl Viro if (!err)
25328bcb77faSAl Viro err = complete_walk(nd);
2533391172c4SAl Viro if (!err) {
2534391172c4SAl Viro *parent = nd->path;
2535391172c4SAl Viro nd->path.mnt = NULL;
2536391172c4SAl Viro nd->path.dentry = NULL;
2537391172c4SAl Viro }
2538deb106c6SAl Viro terminate_walk(nd);
25398bcb77faSAl Viro return err;
25408bcb77faSAl Viro }
25418bcb77faSAl Viro
25420766ec82SStephen Brennan /* Note: this does not consume "name" */
__filename_parentat(int dfd,struct filename * name,unsigned int flags,struct path * parent,struct qstr * last,int * type,const struct path * root)254374d7970fSNamjae Jeon static int __filename_parentat(int dfd, struct filename *name,
2544391172c4SAl Viro unsigned int flags, struct path *parent,
254574d7970fSNamjae Jeon struct qstr *last, int *type,
254674d7970fSNamjae Jeon const struct path *root)
25478bcb77faSAl Viro {
25488bcb77faSAl Viro int retval;
25499883d185SAl Viro struct nameidata nd;
25508bcb77faSAl Viro
25515c31b6ceSAl Viro if (IS_ERR(name))
25520ee50b47SDmitry Kadashev return PTR_ERR(name);
255374d7970fSNamjae Jeon set_nameidata(&nd, dfd, name, root);
2554c8a53ee5SAl Viro retval = path_parentat(&nd, flags | LOOKUP_RCU, parent);
25558bcb77faSAl Viro if (unlikely(retval == -ECHILD))
2556c8a53ee5SAl Viro retval = path_parentat(&nd, flags, parent);
25578bcb77faSAl Viro if (unlikely(retval == -ESTALE))
2558c8a53ee5SAl Viro retval = path_parentat(&nd, flags | LOOKUP_REVAL, parent);
2559391172c4SAl Viro if (likely(!retval)) {
2560391172c4SAl Viro *last = nd.last;
2561391172c4SAl Viro *type = nd.last_type;
2562c9b07eabSAl Viro audit_inode(name, parent->dentry, AUDIT_INODE_PARENT);
2563391172c4SAl Viro }
25649883d185SAl Viro restore_nameidata();
25650ee50b47SDmitry Kadashev return retval;
25660ee50b47SDmitry Kadashev }
25670ee50b47SDmitry Kadashev
filename_parentat(int dfd,struct filename * name,unsigned int flags,struct path * parent,struct qstr * last,int * type)256874d7970fSNamjae Jeon static int filename_parentat(int dfd, struct filename *name,
256974d7970fSNamjae Jeon unsigned int flags, struct path *parent,
257074d7970fSNamjae Jeon struct qstr *last, int *type)
257174d7970fSNamjae Jeon {
257274d7970fSNamjae Jeon return __filename_parentat(dfd, name, flags, parent, last, type, NULL);
257374d7970fSNamjae Jeon }
257474d7970fSNamjae Jeon
257579714f72SAl Viro /* does lookup, returns the object with parent locked */
__kern_path_locked(struct filename * name,struct path * path)25760766ec82SStephen Brennan static struct dentry *__kern_path_locked(struct filename *name, struct path *path)
25775590ff0dSUlrich Drepper {
25785c31b6ceSAl Viro struct dentry *d;
2579391172c4SAl Viro struct qstr last;
25800ee50b47SDmitry Kadashev int type, error;
258151689104SPaul Moore
2582c5f563f9SAl Viro error = filename_parentat(AT_FDCWD, name, 0, path, &last, &type);
25830ee50b47SDmitry Kadashev if (error)
25840ee50b47SDmitry Kadashev return ERR_PTR(error);
25855c31b6ceSAl Viro if (unlikely(type != LAST_NORM)) {
2586391172c4SAl Viro path_put(path);
25875c31b6ceSAl Viro return ERR_PTR(-EINVAL);
258879714f72SAl Viro }
25895955102cSAl Viro inode_lock_nested(path->dentry->d_inode, I_MUTEX_PARENT);
259074d7970fSNamjae Jeon d = lookup_one_qstr_excl(&last, path->dentry, 0);
259179714f72SAl Viro if (IS_ERR(d)) {
25925955102cSAl Viro inode_unlock(path->dentry->d_inode);
2593391172c4SAl Viro path_put(path);
259479714f72SAl Viro }
259579714f72SAl Viro return d;
25965590ff0dSUlrich Drepper }
25975590ff0dSUlrich Drepper
kern_path_locked(const char * name,struct path * path)25980766ec82SStephen Brennan struct dentry *kern_path_locked(const char *name, struct path *path)
25990766ec82SStephen Brennan {
26000766ec82SStephen Brennan struct filename *filename = getname_kernel(name);
26010766ec82SStephen Brennan struct dentry *res = __kern_path_locked(filename, path);
26020766ec82SStephen Brennan
26030766ec82SStephen Brennan putname(filename);
26040766ec82SStephen Brennan return res;
26050766ec82SStephen Brennan }
26060766ec82SStephen Brennan
kern_path(const char * name,unsigned int flags,struct path * path)2607d1811465SAl Viro int kern_path(const char *name, unsigned int flags, struct path *path)
2608d1811465SAl Viro {
2609794ebceaSStephen Brennan struct filename *filename = getname_kernel(name);
2610794ebceaSStephen Brennan int ret = filename_lookup(AT_FDCWD, filename, flags, path, NULL);
2611794ebceaSStephen Brennan
2612794ebceaSStephen Brennan putname(filename);
2613794ebceaSStephen Brennan return ret;
2614794ebceaSStephen Brennan
2615d1811465SAl Viro }
26164d359507SAl Viro EXPORT_SYMBOL(kern_path);
2617d1811465SAl Viro
261816f18200SJosef 'Jeff' Sipek /**
261974d7970fSNamjae Jeon * vfs_path_parent_lookup - lookup a parent path relative to a dentry-vfsmount pair
262074d7970fSNamjae Jeon * @filename: filename structure
262174d7970fSNamjae Jeon * @flags: lookup flags
262274d7970fSNamjae Jeon * @parent: pointer to struct path to fill
262374d7970fSNamjae Jeon * @last: last component
262474d7970fSNamjae Jeon * @type: type of the last component
262574d7970fSNamjae Jeon * @root: pointer to struct path of the base directory
262674d7970fSNamjae Jeon */
vfs_path_parent_lookup(struct filename * filename,unsigned int flags,struct path * parent,struct qstr * last,int * type,const struct path * root)262774d7970fSNamjae Jeon int vfs_path_parent_lookup(struct filename *filename, unsigned int flags,
262874d7970fSNamjae Jeon struct path *parent, struct qstr *last, int *type,
262974d7970fSNamjae Jeon const struct path *root)
263074d7970fSNamjae Jeon {
263174d7970fSNamjae Jeon return __filename_parentat(AT_FDCWD, filename, flags, parent, last,
263274d7970fSNamjae Jeon type, root);
263374d7970fSNamjae Jeon }
263474d7970fSNamjae Jeon EXPORT_SYMBOL(vfs_path_parent_lookup);
263574d7970fSNamjae Jeon
263674d7970fSNamjae Jeon /**
263716f18200SJosef 'Jeff' Sipek * vfs_path_lookup - lookup a file path relative to a dentry-vfsmount pair
263816f18200SJosef 'Jeff' Sipek * @dentry: pointer to dentry of the base directory
263916f18200SJosef 'Jeff' Sipek * @mnt: pointer to vfs mount of the base directory
264016f18200SJosef 'Jeff' Sipek * @name: pointer to file name
264116f18200SJosef 'Jeff' Sipek * @flags: lookup flags
2642e0a01249SAl Viro * @path: pointer to struct path to fill
264316f18200SJosef 'Jeff' Sipek */
vfs_path_lookup(struct dentry * dentry,struct vfsmount * mnt,const char * name,unsigned int flags,struct path * path)264416f18200SJosef 'Jeff' Sipek int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt,
264516f18200SJosef 'Jeff' Sipek const char *name, unsigned int flags,
2646e0a01249SAl Viro struct path *path)
264716f18200SJosef 'Jeff' Sipek {
2648794ebceaSStephen Brennan struct filename *filename;
26499ad1aaa6SAl Viro struct path root = {.mnt = mnt, .dentry = dentry};
2650794ebceaSStephen Brennan int ret;
2651794ebceaSStephen Brennan
2652794ebceaSStephen Brennan filename = getname_kernel(name);
26539ad1aaa6SAl Viro /* the first argument of filename_lookup() is ignored with root */
2654794ebceaSStephen Brennan ret = filename_lookup(AT_FDCWD, filename, flags, path, &root);
2655794ebceaSStephen Brennan putname(filename);
2656794ebceaSStephen Brennan return ret;
265716f18200SJosef 'Jeff' Sipek }
26584d359507SAl Viro EXPORT_SYMBOL(vfs_path_lookup);
265916f18200SJosef 'Jeff' Sipek
lookup_one_common(struct mnt_idmap * idmap,const char * name,struct dentry * base,int len,struct qstr * this)26604609e1f1SChristian Brauner static int lookup_one_common(struct mnt_idmap *idmap,
2661c2fd68b6SChristian Brauner const char *name, struct dentry *base, int len,
2662c2fd68b6SChristian Brauner struct qstr *this)
26633c95f0dcSAl Viro {
26643c95f0dcSAl Viro this->name = name;
26653c95f0dcSAl Viro this->len = len;
26663c95f0dcSAl Viro this->hash = full_name_hash(base, name, len);
26673c95f0dcSAl Viro if (!len)
26683c95f0dcSAl Viro return -EACCES;
26693c95f0dcSAl Viro
26703c95f0dcSAl Viro if (unlikely(name[0] == '.')) {
26713c95f0dcSAl Viro if (len < 2 || (len == 2 && name[1] == '.'))
26723c95f0dcSAl Viro return -EACCES;
26733c95f0dcSAl Viro }
26743c95f0dcSAl Viro
26753c95f0dcSAl Viro while (len--) {
26763c95f0dcSAl Viro unsigned int c = *(const unsigned char *)name++;
26773c95f0dcSAl Viro if (c == '/' || c == '\0')
26783c95f0dcSAl Viro return -EACCES;
26793c95f0dcSAl Viro }
26803c95f0dcSAl Viro /*
26813c95f0dcSAl Viro * See if the low-level filesystem might want
26823c95f0dcSAl Viro * to use its own hash..
26833c95f0dcSAl Viro */
26843c95f0dcSAl Viro if (base->d_flags & DCACHE_OP_HASH) {
26853c95f0dcSAl Viro int err = base->d_op->d_hash(base, this);
26863c95f0dcSAl Viro if (err < 0)
26873c95f0dcSAl Viro return err;
26883c95f0dcSAl Viro }
26893c95f0dcSAl Viro
26904609e1f1SChristian Brauner return inode_permission(idmap, base->d_inode, MAY_EXEC);
26913c95f0dcSAl Viro }
26923c95f0dcSAl Viro
2693eead1911SChristoph Hellwig /**
26940da0b7fdSDavid Howells * try_lookup_one_len - filesystem helper to lookup single pathname component
26950da0b7fdSDavid Howells * @name: pathname component to lookup
26960da0b7fdSDavid Howells * @base: base directory to lookup from
26970da0b7fdSDavid Howells * @len: maximum length @len should be interpreted to
26980da0b7fdSDavid Howells *
26990da0b7fdSDavid Howells * Look up a dentry by name in the dcache, returning NULL if it does not
27000da0b7fdSDavid Howells * currently exist. The function does not try to create a dentry.
27010da0b7fdSDavid Howells *
27020da0b7fdSDavid Howells * Note that this routine is purely a helper for filesystem usage and should
27030da0b7fdSDavid Howells * not be called by generic code.
27040da0b7fdSDavid Howells *
27050da0b7fdSDavid Howells * The caller must hold base->i_mutex.
27060da0b7fdSDavid Howells */
try_lookup_one_len(const char * name,struct dentry * base,int len)27070da0b7fdSDavid Howells struct dentry *try_lookup_one_len(const char *name, struct dentry *base, int len)
27080da0b7fdSDavid Howells {
27090da0b7fdSDavid Howells struct qstr this;
27100da0b7fdSDavid Howells int err;
27110da0b7fdSDavid Howells
27120da0b7fdSDavid Howells WARN_ON_ONCE(!inode_is_locked(base->d_inode));
27130da0b7fdSDavid Howells
27144609e1f1SChristian Brauner err = lookup_one_common(&nop_mnt_idmap, name, base, len, &this);
27150da0b7fdSDavid Howells if (err)
27160da0b7fdSDavid Howells return ERR_PTR(err);
27170da0b7fdSDavid Howells
27180da0b7fdSDavid Howells return lookup_dcache(&this, base, 0);
27190da0b7fdSDavid Howells }
27200da0b7fdSDavid Howells EXPORT_SYMBOL(try_lookup_one_len);
27210da0b7fdSDavid Howells
27220da0b7fdSDavid Howells /**
2723a6b91919SRandy Dunlap * lookup_one_len - filesystem helper to lookup single pathname component
2724eead1911SChristoph Hellwig * @name: pathname component to lookup
2725eead1911SChristoph Hellwig * @base: base directory to lookup from
2726eead1911SChristoph Hellwig * @len: maximum length @len should be interpreted to
2727eead1911SChristoph Hellwig *
2728a6b91919SRandy Dunlap * Note that this routine is purely a helper for filesystem usage and should
27299e7543e9SAl Viro * not be called by generic code.
2730bbddca8eSNeilBrown *
2731bbddca8eSNeilBrown * The caller must hold base->i_mutex.
2732eead1911SChristoph Hellwig */
lookup_one_len(const char * name,struct dentry * base,int len)2733057f6c01SJames Morris struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)
2734057f6c01SJames Morris {
27358613a209SAl Viro struct dentry *dentry;
2736057f6c01SJames Morris struct qstr this;
2737cda309deSMiklos Szeredi int err;
2738057f6c01SJames Morris
27395955102cSAl Viro WARN_ON_ONCE(!inode_is_locked(base->d_inode));
27402f9092e1SDavid Woodhouse
27414609e1f1SChristian Brauner err = lookup_one_common(&nop_mnt_idmap, name, base, len, &this);
2742cda309deSMiklos Szeredi if (err)
2743cda309deSMiklos Szeredi return ERR_PTR(err);
2744cda309deSMiklos Szeredi
27458613a209SAl Viro dentry = lookup_dcache(&this, base, 0);
27468613a209SAl Viro return dentry ? dentry : __lookup_slow(&this, base, 0);
2747057f6c01SJames Morris }
27484d359507SAl Viro EXPORT_SYMBOL(lookup_one_len);
2749057f6c01SJames Morris
2750bbddca8eSNeilBrown /**
2751c2fd68b6SChristian Brauner * lookup_one - filesystem helper to lookup single pathname component
27524609e1f1SChristian Brauner * @idmap: idmap of the mount the lookup is performed from
2753c2fd68b6SChristian Brauner * @name: pathname component to lookup
2754c2fd68b6SChristian Brauner * @base: base directory to lookup from
2755c2fd68b6SChristian Brauner * @len: maximum length @len should be interpreted to
2756c2fd68b6SChristian Brauner *
2757c2fd68b6SChristian Brauner * Note that this routine is purely a helper for filesystem usage and should
2758c2fd68b6SChristian Brauner * not be called by generic code.
2759c2fd68b6SChristian Brauner *
2760c2fd68b6SChristian Brauner * The caller must hold base->i_mutex.
2761c2fd68b6SChristian Brauner */
lookup_one(struct mnt_idmap * idmap,const char * name,struct dentry * base,int len)27624609e1f1SChristian Brauner struct dentry *lookup_one(struct mnt_idmap *idmap, const char *name,
2763c2fd68b6SChristian Brauner struct dentry *base, int len)
2764c2fd68b6SChristian Brauner {
2765c2fd68b6SChristian Brauner struct dentry *dentry;
2766c2fd68b6SChristian Brauner struct qstr this;
2767c2fd68b6SChristian Brauner int err;
2768c2fd68b6SChristian Brauner
2769c2fd68b6SChristian Brauner WARN_ON_ONCE(!inode_is_locked(base->d_inode));
2770c2fd68b6SChristian Brauner
27714609e1f1SChristian Brauner err = lookup_one_common(idmap, name, base, len, &this);
2772c2fd68b6SChristian Brauner if (err)
2773c2fd68b6SChristian Brauner return ERR_PTR(err);
2774c2fd68b6SChristian Brauner
2775c2fd68b6SChristian Brauner dentry = lookup_dcache(&this, base, 0);
2776c2fd68b6SChristian Brauner return dentry ? dentry : __lookup_slow(&this, base, 0);
2777c2fd68b6SChristian Brauner }
2778c2fd68b6SChristian Brauner EXPORT_SYMBOL(lookup_one);
2779c2fd68b6SChristian Brauner
2780c2fd68b6SChristian Brauner /**
278100675017SChristian Brauner * lookup_one_unlocked - filesystem helper to lookup single pathname component
27824609e1f1SChristian Brauner * @idmap: idmap of the mount the lookup is performed from
278300675017SChristian Brauner * @name: pathname component to lookup
278400675017SChristian Brauner * @base: base directory to lookup from
278500675017SChristian Brauner * @len: maximum length @len should be interpreted to
278600675017SChristian Brauner *
278700675017SChristian Brauner * Note that this routine is purely a helper for filesystem usage and should
278800675017SChristian Brauner * not be called by generic code.
278900675017SChristian Brauner *
279000675017SChristian Brauner * Unlike lookup_one_len, it should be called without the parent
279100675017SChristian Brauner * i_mutex held, and will take the i_mutex itself if necessary.
279200675017SChristian Brauner */
lookup_one_unlocked(struct mnt_idmap * idmap,const char * name,struct dentry * base,int len)27934609e1f1SChristian Brauner struct dentry *lookup_one_unlocked(struct mnt_idmap *idmap,
279400675017SChristian Brauner const char *name, struct dentry *base,
279500675017SChristian Brauner int len)
279600675017SChristian Brauner {
279700675017SChristian Brauner struct qstr this;
279800675017SChristian Brauner int err;
279900675017SChristian Brauner struct dentry *ret;
280000675017SChristian Brauner
28014609e1f1SChristian Brauner err = lookup_one_common(idmap, name, base, len, &this);
280200675017SChristian Brauner if (err)
280300675017SChristian Brauner return ERR_PTR(err);
280400675017SChristian Brauner
280500675017SChristian Brauner ret = lookup_dcache(&this, base, 0);
280600675017SChristian Brauner if (!ret)
280700675017SChristian Brauner ret = lookup_slow(&this, base, 0);
280800675017SChristian Brauner return ret;
280900675017SChristian Brauner }
281000675017SChristian Brauner EXPORT_SYMBOL(lookup_one_unlocked);
281100675017SChristian Brauner
281200675017SChristian Brauner /**
281300675017SChristian Brauner * lookup_one_positive_unlocked - filesystem helper to lookup single
281400675017SChristian Brauner * pathname component
28154609e1f1SChristian Brauner * @idmap: idmap of the mount the lookup is performed from
281600675017SChristian Brauner * @name: pathname component to lookup
281700675017SChristian Brauner * @base: base directory to lookup from
281800675017SChristian Brauner * @len: maximum length @len should be interpreted to
281900675017SChristian Brauner *
282000675017SChristian Brauner * This helper will yield ERR_PTR(-ENOENT) on negatives. The helper returns
282100675017SChristian Brauner * known positive or ERR_PTR(). This is what most of the users want.
282200675017SChristian Brauner *
282300675017SChristian Brauner * Note that pinned negative with unlocked parent _can_ become positive at any
282400675017SChristian Brauner * time, so callers of lookup_one_unlocked() need to be very careful; pinned
282500675017SChristian Brauner * positives have >d_inode stable, so this one avoids such problems.
282600675017SChristian Brauner *
282700675017SChristian Brauner * Note that this routine is purely a helper for filesystem usage and should
282800675017SChristian Brauner * not be called by generic code.
282900675017SChristian Brauner *
283000675017SChristian Brauner * The helper should be called without i_mutex held.
283100675017SChristian Brauner */
lookup_one_positive_unlocked(struct mnt_idmap * idmap,const char * name,struct dentry * base,int len)28324609e1f1SChristian Brauner struct dentry *lookup_one_positive_unlocked(struct mnt_idmap *idmap,
283300675017SChristian Brauner const char *name,
283400675017SChristian Brauner struct dentry *base, int len)
283500675017SChristian Brauner {
28364609e1f1SChristian Brauner struct dentry *ret = lookup_one_unlocked(idmap, name, base, len);
283700675017SChristian Brauner
283800675017SChristian Brauner if (!IS_ERR(ret) && d_flags_negative(smp_load_acquire(&ret->d_flags))) {
283900675017SChristian Brauner dput(ret);
284000675017SChristian Brauner ret = ERR_PTR(-ENOENT);
284100675017SChristian Brauner }
284200675017SChristian Brauner return ret;
284300675017SChristian Brauner }
284400675017SChristian Brauner EXPORT_SYMBOL(lookup_one_positive_unlocked);
284500675017SChristian Brauner
284600675017SChristian Brauner /**
2847bbddca8eSNeilBrown * lookup_one_len_unlocked - filesystem helper to lookup single pathname component
2848bbddca8eSNeilBrown * @name: pathname component to lookup
2849bbddca8eSNeilBrown * @base: base directory to lookup from
2850bbddca8eSNeilBrown * @len: maximum length @len should be interpreted to
2851bbddca8eSNeilBrown *
2852bbddca8eSNeilBrown * Note that this routine is purely a helper for filesystem usage and should
2853bbddca8eSNeilBrown * not be called by generic code.
2854bbddca8eSNeilBrown *
2855bbddca8eSNeilBrown * Unlike lookup_one_len, it should be called without the parent
2856bbddca8eSNeilBrown * i_mutex held, and will take the i_mutex itself if necessary.
2857bbddca8eSNeilBrown */
lookup_one_len_unlocked(const char * name,struct dentry * base,int len)2858bbddca8eSNeilBrown struct dentry *lookup_one_len_unlocked(const char *name,
2859bbddca8eSNeilBrown struct dentry *base, int len)
2860bbddca8eSNeilBrown {
28614609e1f1SChristian Brauner return lookup_one_unlocked(&nop_mnt_idmap, name, base, len);
2862bbddca8eSNeilBrown }
2863bbddca8eSNeilBrown EXPORT_SYMBOL(lookup_one_len_unlocked);
2864bbddca8eSNeilBrown
28656c2d4798SAl Viro /*
28666c2d4798SAl Viro * Like lookup_one_len_unlocked(), except that it yields ERR_PTR(-ENOENT)
28676c2d4798SAl Viro * on negatives. Returns known positive or ERR_PTR(); that's what
28686c2d4798SAl Viro * most of the users want. Note that pinned negative with unlocked parent
28696c2d4798SAl Viro * _can_ become positive at any time, so callers of lookup_one_len_unlocked()
28706c2d4798SAl Viro * need to be very careful; pinned positives have ->d_inode stable, so
28716c2d4798SAl Viro * this one avoids such problems.
28726c2d4798SAl Viro */
lookup_positive_unlocked(const char * name,struct dentry * base,int len)28736c2d4798SAl Viro struct dentry *lookup_positive_unlocked(const char *name,
28746c2d4798SAl Viro struct dentry *base, int len)
28756c2d4798SAl Viro {
28764609e1f1SChristian Brauner return lookup_one_positive_unlocked(&nop_mnt_idmap, name, base, len);
28776c2d4798SAl Viro }
28786c2d4798SAl Viro EXPORT_SYMBOL(lookup_positive_unlocked);
28796c2d4798SAl Viro
2880eedf265aSEric W. Biederman #ifdef CONFIG_UNIX98_PTYS
path_pts(struct path * path)2881eedf265aSEric W. Biederman int path_pts(struct path *path)
2882eedf265aSEric W. Biederman {
2883eedf265aSEric W. Biederman /* Find something mounted on "pts" in the same directory as
2884eedf265aSEric W. Biederman * the input path.
2885eedf265aSEric W. Biederman */
2886a6a7eb76SAl Viro struct dentry *parent = dget_parent(path->dentry);
2887a6a7eb76SAl Viro struct dentry *child;
288819f6028aSAl Viro struct qstr this = QSTR_INIT("pts", 3);
2889eedf265aSEric W. Biederman
2890a6a7eb76SAl Viro if (unlikely(!path_connected(path->mnt, parent))) {
2891a6a7eb76SAl Viro dput(parent);
289263b27720SAl Viro return -ENOENT;
2893a6a7eb76SAl Viro }
289463b27720SAl Viro dput(path->dentry);
289563b27720SAl Viro path->dentry = parent;
2896eedf265aSEric W. Biederman child = d_hash_and_lookup(parent, &this);
28970d5a4f8fSWang Ming if (IS_ERR_OR_NULL(child))
2898eedf265aSEric W. Biederman return -ENOENT;
2899eedf265aSEric W. Biederman
2900eedf265aSEric W. Biederman path->dentry = child;
2901eedf265aSEric W. Biederman dput(parent);
2902e1f19857SRichard Weinberger follow_down(path, 0);
2903eedf265aSEric W. Biederman return 0;
2904eedf265aSEric W. Biederman }
2905eedf265aSEric W. Biederman #endif
2906eedf265aSEric W. Biederman
user_path_at_empty(int dfd,const char __user * name,unsigned flags,struct path * path,int * empty)29071fa1e7f6SAndy Whitcroft int user_path_at_empty(int dfd, const char __user *name, unsigned flags,
29081fa1e7f6SAndy Whitcroft struct path *path, int *empty)
29091da177e4SLinus Torvalds {
2910794ebceaSStephen Brennan struct filename *filename = getname_flags(name, flags, empty);
2911794ebceaSStephen Brennan int ret = filename_lookup(dfd, filename, flags, path, NULL);
2912794ebceaSStephen Brennan
2913794ebceaSStephen Brennan putname(filename);
2914794ebceaSStephen Brennan return ret;
29151da177e4SLinus Torvalds }
2916b853a161SAl Viro EXPORT_SYMBOL(user_path_at_empty);
29171fa1e7f6SAndy Whitcroft
__check_sticky(struct mnt_idmap * idmap,struct inode * dir,struct inode * inode)29189452e93eSChristian Brauner int __check_sticky(struct mnt_idmap *idmap, struct inode *dir,
2919ba73d987SChristian Brauner struct inode *inode)
29201da177e4SLinus Torvalds {
29218e96e3b7SEric W. Biederman kuid_t fsuid = current_fsuid();
2922da9592edSDavid Howells
2923e67fe633SChristian Brauner if (vfsuid_eq_kuid(i_uid_into_vfsuid(idmap, inode), fsuid))
29241da177e4SLinus Torvalds return 0;
2925e67fe633SChristian Brauner if (vfsuid_eq_kuid(i_uid_into_vfsuid(idmap, dir), fsuid))
29261da177e4SLinus Torvalds return 0;
29279452e93eSChristian Brauner return !capable_wrt_inode_uidgid(idmap, inode, CAP_FOWNER);
29281da177e4SLinus Torvalds }
2929cbdf35bcSMiklos Szeredi EXPORT_SYMBOL(__check_sticky);
29301da177e4SLinus Torvalds
29311da177e4SLinus Torvalds /*
29321da177e4SLinus Torvalds * Check whether we can remove a link victim from directory dir, check
29331da177e4SLinus Torvalds * whether the type of victim is right.
29341da177e4SLinus Torvalds * 1. We can't do it if dir is read-only (done in permission())
29351da177e4SLinus Torvalds * 2. We should have write and exec permissions on dir
29361da177e4SLinus Torvalds * 3. We can't remove anything from append-only dir
29371da177e4SLinus Torvalds * 4. We can't do anything with immutable dir (done in permission())
29381da177e4SLinus Torvalds * 5. If the sticky bit on dir is set we should either
29391da177e4SLinus Torvalds * a. be owner of dir, or
29401da177e4SLinus Torvalds * b. be owner of victim, or
29411da177e4SLinus Torvalds * c. have CAP_FOWNER capability
29421da177e4SLinus Torvalds * 6. If the victim is append-only or immutable we can't do antyhing with
29431da177e4SLinus Torvalds * links pointing to it.
29440bd23d09SEric W. Biederman * 7. If the victim has an unknown uid or gid we can't change the inode.
29450bd23d09SEric W. Biederman * 8. If we were asked to remove a directory and victim isn't one - ENOTDIR.
29460bd23d09SEric W. Biederman * 9. If we were asked to remove a non-directory and victim isn't one - EISDIR.
29470bd23d09SEric W. Biederman * 10. We can't remove a root or mountpoint.
29480bd23d09SEric W. Biederman * 11. We don't allow removal of NFS sillyrenamed files; it's handled by
29491da177e4SLinus Torvalds * nfs_async_unlink().
29501da177e4SLinus Torvalds */
may_delete(struct mnt_idmap * idmap,struct inode * dir,struct dentry * victim,bool isdir)29514609e1f1SChristian Brauner static int may_delete(struct mnt_idmap *idmap, struct inode *dir,
2952ba73d987SChristian Brauner struct dentry *victim, bool isdir)
29531da177e4SLinus Torvalds {
295463afdfc7SDavid Howells struct inode *inode = d_backing_inode(victim);
29551da177e4SLinus Torvalds int error;
29561da177e4SLinus Torvalds
2957b18825a7SDavid Howells if (d_is_negative(victim))
29581da177e4SLinus Torvalds return -ENOENT;
2959b18825a7SDavid Howells BUG_ON(!inode);
29601da177e4SLinus Torvalds
29611da177e4SLinus Torvalds BUG_ON(victim->d_parent->d_inode != dir);
2962593d1ce8SEric W. Biederman
2963593d1ce8SEric W. Biederman /* Inode writeback is not safe when the uid or gid are invalid. */
2964e67fe633SChristian Brauner if (!vfsuid_valid(i_uid_into_vfsuid(idmap, inode)) ||
2965e67fe633SChristian Brauner !vfsgid_valid(i_gid_into_vfsgid(idmap, inode)))
2966593d1ce8SEric W. Biederman return -EOVERFLOW;
2967593d1ce8SEric W. Biederman
29684fa6b5ecSJeff Layton audit_inode_child(dir, victim, AUDIT_TYPE_CHILD_DELETE);
29691da177e4SLinus Torvalds
29704609e1f1SChristian Brauner error = inode_permission(idmap, dir, MAY_WRITE | MAY_EXEC);
29711da177e4SLinus Torvalds if (error)
29721da177e4SLinus Torvalds return error;
29731da177e4SLinus Torvalds if (IS_APPEND(dir))
29741da177e4SLinus Torvalds return -EPERM;
2975b18825a7SDavid Howells
29769452e93eSChristian Brauner if (check_sticky(idmap, dir, inode) || IS_APPEND(inode) ||
2977ba73d987SChristian Brauner IS_IMMUTABLE(inode) || IS_SWAPFILE(inode) ||
29784609e1f1SChristian Brauner HAS_UNMAPPED_ID(idmap, inode))
29791da177e4SLinus Torvalds return -EPERM;
29801da177e4SLinus Torvalds if (isdir) {
298144b1d530SMiklos Szeredi if (!d_is_dir(victim))
29821da177e4SLinus Torvalds return -ENOTDIR;
29831da177e4SLinus Torvalds if (IS_ROOT(victim))
29841da177e4SLinus Torvalds return -EBUSY;
298544b1d530SMiklos Szeredi } else if (d_is_dir(victim))
29861da177e4SLinus Torvalds return -EISDIR;
29871da177e4SLinus Torvalds if (IS_DEADDIR(dir))
29881da177e4SLinus Torvalds return -ENOENT;
29891da177e4SLinus Torvalds if (victim->d_flags & DCACHE_NFSFS_RENAMED)
29901da177e4SLinus Torvalds return -EBUSY;
29911da177e4SLinus Torvalds return 0;
29921da177e4SLinus Torvalds }
29931da177e4SLinus Torvalds
29941da177e4SLinus Torvalds /* Check whether we can create an object with dentry child in directory
29951da177e4SLinus Torvalds * dir.
29961da177e4SLinus Torvalds * 1. We can't do it if child already exists (open has special treatment for
29971da177e4SLinus Torvalds * this case, but since we are inlined it's OK)
29981da177e4SLinus Torvalds * 2. We can't do it if dir is read-only (done in permission())
2999036d5236SEric W. Biederman * 3. We can't do it if the fs can't represent the fsuid or fsgid.
3000036d5236SEric W. Biederman * 4. We should have write and exec permissions on dir
3001036d5236SEric W. Biederman * 5. We can't do it if dir is immutable (done in permission())
30021da177e4SLinus Torvalds */
may_create(struct mnt_idmap * idmap,struct inode * dir,struct dentry * child)30034609e1f1SChristian Brauner static inline int may_create(struct mnt_idmap *idmap,
3004ba73d987SChristian Brauner struct inode *dir, struct dentry *child)
30051da177e4SLinus Torvalds {
300614e972b4SJeff Layton audit_inode_child(dir, child, AUDIT_TYPE_CHILD_CREATE);
30071da177e4SLinus Torvalds if (child->d_inode)
30081da177e4SLinus Torvalds return -EEXIST;
30091da177e4SLinus Torvalds if (IS_DEADDIR(dir))
30101da177e4SLinus Torvalds return -ENOENT;
30114609e1f1SChristian Brauner if (!fsuidgid_has_mapping(dir->i_sb, idmap))
3012036d5236SEric W. Biederman return -EOVERFLOW;
30138e538913SChristian Brauner
30144609e1f1SChristian Brauner return inode_permission(idmap, dir, MAY_WRITE | MAY_EXEC);
30151da177e4SLinus Torvalds }
30161da177e4SLinus Torvalds
lock_two_directories(struct dentry * p1,struct dentry * p2)30179bc37e04SAl Viro static struct dentry *lock_two_directories(struct dentry *p1, struct dentry *p2)
30181da177e4SLinus Torvalds {
30191da177e4SLinus Torvalds struct dentry *p;
30201da177e4SLinus Torvalds
3021e2761a11SOGAWA Hirofumi p = d_ancestor(p2, p1);
3022e2761a11SOGAWA Hirofumi if (p) {
30235955102cSAl Viro inode_lock_nested(p2->d_inode, I_MUTEX_PARENT);
3024*1db06b3dSAl Viro inode_lock_nested(p1->d_inode, I_MUTEX_PARENT2);
30251da177e4SLinus Torvalds return p;
30261da177e4SLinus Torvalds }
30271da177e4SLinus Torvalds
3028e2761a11SOGAWA Hirofumi p = d_ancestor(p1, p2);
30295955102cSAl Viro inode_lock_nested(p1->d_inode, I_MUTEX_PARENT);
3030*1db06b3dSAl Viro inode_lock_nested(p2->d_inode, I_MUTEX_PARENT2);
30311da177e4SLinus Torvalds return p;
30321da177e4SLinus Torvalds }
30331da177e4SLinus Torvalds
30349bc37e04SAl Viro /*
30359bc37e04SAl Viro * p1 and p2 should be directories on the same fs.
30369bc37e04SAl Viro */
lock_rename(struct dentry * p1,struct dentry * p2)30379bc37e04SAl Viro struct dentry *lock_rename(struct dentry *p1, struct dentry *p2)
30389bc37e04SAl Viro {
30399bc37e04SAl Viro if (p1 == p2) {
30409bc37e04SAl Viro inode_lock_nested(p1->d_inode, I_MUTEX_PARENT);
30419bc37e04SAl Viro return NULL;
30429bc37e04SAl Viro }
30439bc37e04SAl Viro
30449bc37e04SAl Viro mutex_lock(&p1->d_sb->s_vfs_rename_mutex);
30459bc37e04SAl Viro return lock_two_directories(p1, p2);
30469bc37e04SAl Viro }
30474d359507SAl Viro EXPORT_SYMBOL(lock_rename);
30481da177e4SLinus Torvalds
30499bc37e04SAl Viro /*
30509bc37e04SAl Viro * c1 and p2 should be on the same fs.
30519bc37e04SAl Viro */
lock_rename_child(struct dentry * c1,struct dentry * p2)30529bc37e04SAl Viro struct dentry *lock_rename_child(struct dentry *c1, struct dentry *p2)
30539bc37e04SAl Viro {
30549bc37e04SAl Viro if (READ_ONCE(c1->d_parent) == p2) {
30559bc37e04SAl Viro /*
30569bc37e04SAl Viro * hopefully won't need to touch ->s_vfs_rename_mutex at all.
30579bc37e04SAl Viro */
30589bc37e04SAl Viro inode_lock_nested(p2->d_inode, I_MUTEX_PARENT);
30599bc37e04SAl Viro /*
30609bc37e04SAl Viro * now that p2 is locked, nobody can move in or out of it,
30619bc37e04SAl Viro * so the test below is safe.
30629bc37e04SAl Viro */
30639bc37e04SAl Viro if (likely(c1->d_parent == p2))
30649bc37e04SAl Viro return NULL;
30659bc37e04SAl Viro
30669bc37e04SAl Viro /*
30679bc37e04SAl Viro * c1 got moved out of p2 while we'd been taking locks;
30689bc37e04SAl Viro * unlock and fall back to slow case.
30699bc37e04SAl Viro */
30709bc37e04SAl Viro inode_unlock(p2->d_inode);
30719bc37e04SAl Viro }
30729bc37e04SAl Viro
30739bc37e04SAl Viro mutex_lock(&c1->d_sb->s_vfs_rename_mutex);
30749bc37e04SAl Viro /*
30759bc37e04SAl Viro * nobody can move out of any directories on this fs.
30769bc37e04SAl Viro */
30779bc37e04SAl Viro if (likely(c1->d_parent != p2))
30789bc37e04SAl Viro return lock_two_directories(c1->d_parent, p2);
30799bc37e04SAl Viro
30809bc37e04SAl Viro /*
30819bc37e04SAl Viro * c1 got moved into p2 while we were taking locks;
30829bc37e04SAl Viro * we need p2 locked and ->s_vfs_rename_mutex unlocked,
30839bc37e04SAl Viro * for consistency with lock_rename().
30849bc37e04SAl Viro */
30859bc37e04SAl Viro inode_lock_nested(p2->d_inode, I_MUTEX_PARENT);
30869bc37e04SAl Viro mutex_unlock(&c1->d_sb->s_vfs_rename_mutex);
30879bc37e04SAl Viro return NULL;
30889bc37e04SAl Viro }
30899bc37e04SAl Viro EXPORT_SYMBOL(lock_rename_child);
30909bc37e04SAl Viro
unlock_rename(struct dentry * p1,struct dentry * p2)30911da177e4SLinus Torvalds void unlock_rename(struct dentry *p1, struct dentry *p2)
30921da177e4SLinus Torvalds {
30935955102cSAl Viro inode_unlock(p1->d_inode);
30941da177e4SLinus Torvalds if (p1 != p2) {
30955955102cSAl Viro inode_unlock(p2->d_inode);
3096fc64005cSAl Viro mutex_unlock(&p1->d_sb->s_vfs_rename_mutex);
30971da177e4SLinus Torvalds }
30981da177e4SLinus Torvalds }
30994d359507SAl Viro EXPORT_SYMBOL(unlock_rename);
31001da177e4SLinus Torvalds
31016521f891SChristian Brauner /**
31021639a49cSYang Xu * mode_strip_umask - handle vfs umask stripping
31031639a49cSYang Xu * @dir: parent directory of the new inode
31041639a49cSYang Xu * @mode: mode of the new inode to be created in @dir
31051639a49cSYang Xu *
31061639a49cSYang Xu * Umask stripping depends on whether or not the filesystem supports POSIX
31071639a49cSYang Xu * ACLs. If the filesystem doesn't support it umask stripping is done directly
31081639a49cSYang Xu * in here. If the filesystem does support POSIX ACLs umask stripping is
31091639a49cSYang Xu * deferred until the filesystem calls posix_acl_create().
31101639a49cSYang Xu *
31111639a49cSYang Xu * Returns: mode
31121639a49cSYang Xu */
mode_strip_umask(const struct inode * dir,umode_t mode)31131639a49cSYang Xu static inline umode_t mode_strip_umask(const struct inode *dir, umode_t mode)
31141639a49cSYang Xu {
31151639a49cSYang Xu if (!IS_POSIXACL(dir))
31161639a49cSYang Xu mode &= ~current_umask();
31171639a49cSYang Xu return mode;
31181639a49cSYang Xu }
31191639a49cSYang Xu
31201639a49cSYang Xu /**
31211639a49cSYang Xu * vfs_prepare_mode - prepare the mode to be used for a new inode
31229452e93eSChristian Brauner * @idmap: idmap of the mount the inode was found from
31231639a49cSYang Xu * @dir: parent directory of the new inode
31241639a49cSYang Xu * @mode: mode of the new inode
31251639a49cSYang Xu * @mask_perms: allowed permission by the vfs
31261639a49cSYang Xu * @type: type of file to be created
31271639a49cSYang Xu *
31281639a49cSYang Xu * This helper consolidates and enforces vfs restrictions on the @mode of a new
31291639a49cSYang Xu * object to be created.
31301639a49cSYang Xu *
31311639a49cSYang Xu * Umask stripping depends on whether the filesystem supports POSIX ACLs (see
31321639a49cSYang Xu * the kernel documentation for mode_strip_umask()). Moving umask stripping
31331639a49cSYang Xu * after setgid stripping allows the same ordering for both non-POSIX ACL and
31341639a49cSYang Xu * POSIX ACL supporting filesystems.
31351639a49cSYang Xu *
31361639a49cSYang Xu * Note that it's currently valid for @type to be 0 if a directory is created.
31371639a49cSYang Xu * Filesystems raise that flag individually and we need to check whether each
31381639a49cSYang Xu * filesystem can deal with receiving S_IFDIR from the vfs before we enforce a
31391639a49cSYang Xu * non-zero type.
31401639a49cSYang Xu *
31411639a49cSYang Xu * Returns: mode to be passed to the filesystem
31421639a49cSYang Xu */
vfs_prepare_mode(struct mnt_idmap * idmap,const struct inode * dir,umode_t mode,umode_t mask_perms,umode_t type)31439452e93eSChristian Brauner static inline umode_t vfs_prepare_mode(struct mnt_idmap *idmap,
31441639a49cSYang Xu const struct inode *dir, umode_t mode,
31451639a49cSYang Xu umode_t mask_perms, umode_t type)
31461639a49cSYang Xu {
31479452e93eSChristian Brauner mode = mode_strip_sgid(idmap, dir, mode);
31481639a49cSYang Xu mode = mode_strip_umask(dir, mode);
31491639a49cSYang Xu
31501639a49cSYang Xu /*
31511639a49cSYang Xu * Apply the vfs mandated allowed permission mask and set the type of
31521639a49cSYang Xu * file to be created before we call into the filesystem.
31531639a49cSYang Xu */
31541639a49cSYang Xu mode &= (mask_perms & ~S_IFMT);
31551639a49cSYang Xu mode |= (type & S_IFMT);
31561639a49cSYang Xu
31571639a49cSYang Xu return mode;
31581639a49cSYang Xu }
31591639a49cSYang Xu
31601639a49cSYang Xu /**
31616521f891SChristian Brauner * vfs_create - create new file
3162abf08576SChristian Brauner * @idmap: idmap of the mount the inode was found from
31636521f891SChristian Brauner * @dir: inode of @dentry
31646521f891SChristian Brauner * @dentry: pointer to dentry of the base directory
31656521f891SChristian Brauner * @mode: mode of the new file
31666521f891SChristian Brauner * @want_excl: whether the file must not yet exist
31676521f891SChristian Brauner *
31686521f891SChristian Brauner * Create a new file.
31696521f891SChristian Brauner *
3170abf08576SChristian Brauner * If the inode has been found through an idmapped mount the idmap of
3171abf08576SChristian Brauner * the vfsmount must be passed through @idmap. This function will then take
3172abf08576SChristian Brauner * care to map the inode according to @idmap before checking permissions.
31736521f891SChristian Brauner * On non-idmapped mounts or if permission checking is to be performed on the
3174abf08576SChristian Brauner * raw inode simply passs @nop_mnt_idmap.
31756521f891SChristian Brauner */
vfs_create(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry,umode_t mode,bool want_excl)3176abf08576SChristian Brauner int vfs_create(struct mnt_idmap *idmap, struct inode *dir,
31776521f891SChristian Brauner struct dentry *dentry, umode_t mode, bool want_excl)
31781da177e4SLinus Torvalds {
3179abf08576SChristian Brauner int error;
3180abf08576SChristian Brauner
31814609e1f1SChristian Brauner error = may_create(idmap, dir, dentry);
31821da177e4SLinus Torvalds if (error)
31831da177e4SLinus Torvalds return error;
31841da177e4SLinus Torvalds
3185acfa4380SAl Viro if (!dir->i_op->create)
31861da177e4SLinus Torvalds return -EACCES; /* shouldn't it be ENOSYS? */
31871639a49cSYang Xu
31889452e93eSChristian Brauner mode = vfs_prepare_mode(idmap, dir, mode, S_IALLUGO, S_IFREG);
31891da177e4SLinus Torvalds error = security_inode_create(dir, dentry, mode);
31901da177e4SLinus Torvalds if (error)
31911da177e4SLinus Torvalds return error;
31926c960e68SChristian Brauner error = dir->i_op->create(idmap, dir, dentry, mode, want_excl);
3193a74574aaSStephen Smalley if (!error)
3194f38aa942SAmy Griffis fsnotify_create(dir, dentry);
31951da177e4SLinus Torvalds return error;
31961da177e4SLinus Torvalds }
31974d359507SAl Viro EXPORT_SYMBOL(vfs_create);
31981da177e4SLinus Torvalds
vfs_mkobj(struct dentry * dentry,umode_t mode,int (* f)(struct dentry *,umode_t,void *),void * arg)31998e6c848eSAl Viro int vfs_mkobj(struct dentry *dentry, umode_t mode,
32008e6c848eSAl Viro int (*f)(struct dentry *, umode_t, void *),
32018e6c848eSAl Viro void *arg)
32028e6c848eSAl Viro {
32038e6c848eSAl Viro struct inode *dir = dentry->d_parent->d_inode;
32044609e1f1SChristian Brauner int error = may_create(&nop_mnt_idmap, dir, dentry);
32058e6c848eSAl Viro if (error)
32068e6c848eSAl Viro return error;
32078e6c848eSAl Viro
32088e6c848eSAl Viro mode &= S_IALLUGO;
32098e6c848eSAl Viro mode |= S_IFREG;
32108e6c848eSAl Viro error = security_inode_create(dir, dentry, mode);
32118e6c848eSAl Viro if (error)
32128e6c848eSAl Viro return error;
32138e6c848eSAl Viro error = f(dentry, mode, arg);
32148e6c848eSAl Viro if (!error)
32158e6c848eSAl Viro fsnotify_create(dir, dentry);
32168e6c848eSAl Viro return error;
32178e6c848eSAl Viro }
32188e6c848eSAl Viro EXPORT_SYMBOL(vfs_mkobj);
32198e6c848eSAl Viro
may_open_dev(const struct path * path)3220a2982cc9SEric W. Biederman bool may_open_dev(const struct path *path)
3221a2982cc9SEric W. Biederman {
3222a2982cc9SEric W. Biederman return !(path->mnt->mnt_flags & MNT_NODEV) &&
3223a2982cc9SEric W. Biederman !(path->mnt->mnt_sb->s_iflags & SB_I_NODEV);
3224a2982cc9SEric W. Biederman }
3225a2982cc9SEric W. Biederman
may_open(struct mnt_idmap * idmap,const struct path * path,int acc_mode,int flag)32264609e1f1SChristian Brauner static int may_open(struct mnt_idmap *idmap, const struct path *path,
3227ba73d987SChristian Brauner int acc_mode, int flag)
32281da177e4SLinus Torvalds {
32293fb64190SChristoph Hellwig struct dentry *dentry = path->dentry;
32301da177e4SLinus Torvalds struct inode *inode = dentry->d_inode;
32311da177e4SLinus Torvalds int error;
32321da177e4SLinus Torvalds
32331da177e4SLinus Torvalds if (!inode)
32341da177e4SLinus Torvalds return -ENOENT;
32351da177e4SLinus Torvalds
3236c8fe8f30SChristoph Hellwig switch (inode->i_mode & S_IFMT) {
3237c8fe8f30SChristoph Hellwig case S_IFLNK:
32381da177e4SLinus Torvalds return -ELOOP;
3239c8fe8f30SChristoph Hellwig case S_IFDIR:
3240fc4177beSKees Cook if (acc_mode & MAY_WRITE)
32411da177e4SLinus Torvalds return -EISDIR;
3242fc4177beSKees Cook if (acc_mode & MAY_EXEC)
3243fc4177beSKees Cook return -EACCES;
3244c8fe8f30SChristoph Hellwig break;
3245c8fe8f30SChristoph Hellwig case S_IFBLK:
3246c8fe8f30SChristoph Hellwig case S_IFCHR:
3247a2982cc9SEric W. Biederman if (!may_open_dev(path))
32481da177e4SLinus Torvalds return -EACCES;
3249633fb6acSKees Cook fallthrough;
3250c8fe8f30SChristoph Hellwig case S_IFIFO:
3251c8fe8f30SChristoph Hellwig case S_IFSOCK:
3252633fb6acSKees Cook if (acc_mode & MAY_EXEC)
3253633fb6acSKees Cook return -EACCES;
32541da177e4SLinus Torvalds flag &= ~O_TRUNC;
3255c8fe8f30SChristoph Hellwig break;
32560fd338b2SKees Cook case S_IFREG:
32570fd338b2SKees Cook if ((acc_mode & MAY_EXEC) && path_noexec(path))
32580fd338b2SKees Cook return -EACCES;
32590fd338b2SKees Cook break;
32604a3fd211SDave Hansen }
3261b41572e9SDave Hansen
32624609e1f1SChristian Brauner error = inode_permission(idmap, inode, MAY_OPEN | acc_mode);
3263b41572e9SDave Hansen if (error)
3264b41572e9SDave Hansen return error;
32656146f0d5SMimi Zohar
32661da177e4SLinus Torvalds /*
32671da177e4SLinus Torvalds * An append-only file must be opened in append mode for writing.
32681da177e4SLinus Torvalds */
32691da177e4SLinus Torvalds if (IS_APPEND(inode)) {
32708737c930SAl Viro if ((flag & O_ACCMODE) != O_RDONLY && !(flag & O_APPEND))
32717715b521SAl Viro return -EPERM;
32721da177e4SLinus Torvalds if (flag & O_TRUNC)
32737715b521SAl Viro return -EPERM;
32741da177e4SLinus Torvalds }
32751da177e4SLinus Torvalds
32761da177e4SLinus Torvalds /* O_NOATIME can only be set by the owner or superuser */
327701beba79SChristian Brauner if (flag & O_NOATIME && !inode_owner_or_capable(idmap, inode))
32787715b521SAl Viro return -EPERM;
32791da177e4SLinus Torvalds
3280f3c7691eSJ. Bruce Fields return 0;
32817715b521SAl Viro }
32827715b521SAl Viro
handle_truncate(struct mnt_idmap * idmap,struct file * filp)3283abf08576SChristian Brauner static int handle_truncate(struct mnt_idmap *idmap, struct file *filp)
32847715b521SAl Viro {
3285f0bb5aafSAl Viro const struct path *path = &filp->f_path;
32867715b521SAl Viro struct inode *inode = path->dentry->d_inode;
32877715b521SAl Viro int error = get_write_access(inode);
32881da177e4SLinus Torvalds if (error)
32897715b521SAl Viro return error;
3290482e0007SJeff Layton
32913350607dSGünther Noack error = security_file_truncate(filp);
32921da177e4SLinus Torvalds if (!error) {
3293abf08576SChristian Brauner error = do_truncate(idmap, path->dentry, 0,
3294d139d7ffSMiklos Szeredi ATTR_MTIME|ATTR_CTIME|ATTR_OPEN,
3295e1181ee6SJeff Layton filp);
32961da177e4SLinus Torvalds }
32971da177e4SLinus Torvalds put_write_access(inode);
3298acd0c935SMimi Zohar return error;
32991da177e4SLinus Torvalds }
33001da177e4SLinus Torvalds
open_to_namei_flags(int flag)3301d57999e1SDave Hansen static inline int open_to_namei_flags(int flag)
3302d57999e1SDave Hansen {
33038a5e929dSAl Viro if ((flag & O_ACCMODE) == 3)
33048a5e929dSAl Viro flag--;
3305d57999e1SDave Hansen return flag;
3306d57999e1SDave Hansen }
3307d57999e1SDave Hansen
may_o_create(struct mnt_idmap * idmap,const struct path * dir,struct dentry * dentry,umode_t mode)33084609e1f1SChristian Brauner static int may_o_create(struct mnt_idmap *idmap,
3309ba73d987SChristian Brauner const struct path *dir, struct dentry *dentry,
3310ba73d987SChristian Brauner umode_t mode)
3311d18e9008SMiklos Szeredi {
3312d18e9008SMiklos Szeredi int error = security_path_mknod(dir, dentry, mode, 0);
3313d18e9008SMiklos Szeredi if (error)
3314d18e9008SMiklos Szeredi return error;
3315d18e9008SMiklos Szeredi
33164609e1f1SChristian Brauner if (!fsuidgid_has_mapping(dir->dentry->d_sb, idmap))
33171328c727SSeth Forshee return -EOVERFLOW;
33181328c727SSeth Forshee
33194609e1f1SChristian Brauner error = inode_permission(idmap, dir->dentry->d_inode,
332047291baaSChristian Brauner MAY_WRITE | MAY_EXEC);
3321d18e9008SMiklos Szeredi if (error)
3322d18e9008SMiklos Szeredi return error;
3323d18e9008SMiklos Szeredi
3324d18e9008SMiklos Szeredi return security_inode_create(dir->dentry->d_inode, dentry, mode);
3325d18e9008SMiklos Szeredi }
3326d18e9008SMiklos Szeredi
33271acf0af9SDavid Howells /*
33281acf0af9SDavid Howells * Attempt to atomically look up, create and open a file from a negative
33291acf0af9SDavid Howells * dentry.
33301acf0af9SDavid Howells *
33311acf0af9SDavid Howells * Returns 0 if successful. The file will have been created and attached to
33321acf0af9SDavid Howells * @file by the filesystem calling finish_open().
33331acf0af9SDavid Howells *
333400a07c15SAl Viro * If the file was looked up only or didn't need creating, FMODE_OPENED won't
333500a07c15SAl Viro * be set. The caller will need to perform the open themselves. @path will
333600a07c15SAl Viro * have been updated to point to the new dentry. This may be negative.
33371acf0af9SDavid Howells *
33381acf0af9SDavid Howells * Returns an error code otherwise.
33391acf0af9SDavid Howells */
atomic_open(struct nameidata * nd,struct dentry * dentry,struct file * file,int open_flag,umode_t mode)3340239eb983SAl Viro static struct dentry *atomic_open(struct nameidata *nd, struct dentry *dentry,
3341239eb983SAl Viro struct file *file,
33423ec2eef1SAl Viro int open_flag, umode_t mode)
3343d18e9008SMiklos Szeredi {
3344d18e9008SMiklos Szeredi struct dentry *const DENTRY_NOT_SET = (void *) -1UL;
3345d18e9008SMiklos Szeredi struct inode *dir = nd->path.dentry->d_inode;
3346d18e9008SMiklos Szeredi int error;
3347d18e9008SMiklos Szeredi
3348d18e9008SMiklos Szeredi if (nd->flags & LOOKUP_DIRECTORY)
3349d18e9008SMiklos Szeredi open_flag |= O_DIRECTORY;
3350d18e9008SMiklos Szeredi
335130d90494SAl Viro file->f_path.dentry = DENTRY_NOT_SET;
335230d90494SAl Viro file->f_path.mnt = nd->path.mnt;
33530fb1ea09SAl Viro error = dir->i_op->atomic_open(dir, dentry, file,
335444907d79SAl Viro open_to_namei_flags(open_flag), mode);
33556fbd0714SAl Viro d_lookup_done(dentry);
3356384f26e2SAl Viro if (!error) {
335764e1ac4dSAl Viro if (file->f_mode & FMODE_OPENED) {
33586fb968cdSAl Viro if (unlikely(dentry != file->f_path.dentry)) {
33596fb968cdSAl Viro dput(dentry);
33606fb968cdSAl Viro dentry = dget(file->f_path.dentry);
33616fb968cdSAl Viro }
336264e1ac4dSAl Viro } else if (WARN_ON(file->f_path.dentry == DENTRY_NOT_SET)) {
33632675a4ebSAl Viro error = -EIO;
3364384f26e2SAl Viro } else {
336530d90494SAl Viro if (file->f_path.dentry) {
3366d18e9008SMiklos Szeredi dput(dentry);
3367d18e9008SMiklos Szeredi dentry = file->f_path.dentry;
336810c64ceaSAl Viro }
3369239eb983SAl Viro if (unlikely(d_is_negative(dentry)))
3370a01e718fSAl Viro error = -ENOENT;
3371d18e9008SMiklos Szeredi }
3372d18e9008SMiklos Szeredi }
3373239eb983SAl Viro if (error) {
3374d18e9008SMiklos Szeredi dput(dentry);
3375239eb983SAl Viro dentry = ERR_PTR(error);
3376239eb983SAl Viro }
3377239eb983SAl Viro return dentry;
3378d18e9008SMiklos Szeredi }
3379d18e9008SMiklos Szeredi
338031e6b01fSNick Piggin /*
33811acf0af9SDavid Howells * Look up and maybe create and open the last component.
3382d58ffd35SMiklos Szeredi *
338300a07c15SAl Viro * Must be called with parent locked (exclusive in O_CREAT case).
3384d58ffd35SMiklos Szeredi *
338500a07c15SAl Viro * Returns 0 on success, that is, if
338600a07c15SAl Viro * the file was successfully atomically created (if necessary) and opened, or
338700a07c15SAl Viro * the file was not completely opened at this time, though lookups and
338800a07c15SAl Viro * creations were performed.
338900a07c15SAl Viro * These case are distinguished by presence of FMODE_OPENED on file->f_mode.
339000a07c15SAl Viro * In the latter case dentry returned in @path might be negative if O_CREAT
339100a07c15SAl Viro * hadn't been specified.
33921acf0af9SDavid Howells *
339300a07c15SAl Viro * An error code is returned on failure.
3394d58ffd35SMiklos Szeredi */
lookup_open(struct nameidata * nd,struct file * file,const struct open_flags * op,bool got_write)3395da5ebf5aSAl Viro static struct dentry *lookup_open(struct nameidata *nd, struct file *file,
3396d58ffd35SMiklos Szeredi const struct open_flags *op,
33973ec2eef1SAl Viro bool got_write)
3398d58ffd35SMiklos Szeredi {
33996c960e68SChristian Brauner struct mnt_idmap *idmap;
3400d58ffd35SMiklos Szeredi struct dentry *dir = nd->path.dentry;
340154ef4872SMiklos Szeredi struct inode *dir_inode = dir->d_inode;
34021643b43fSAl Viro int open_flag = op->open_flag;
3403d58ffd35SMiklos Szeredi struct dentry *dentry;
34041643b43fSAl Viro int error, create_error = 0;
34051643b43fSAl Viro umode_t mode = op->mode;
34066fbd0714SAl Viro DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
3407d58ffd35SMiklos Szeredi
3408ce8644fcSAl Viro if (unlikely(IS_DEADDIR(dir_inode)))
3409da5ebf5aSAl Viro return ERR_PTR(-ENOENT);
3410d58ffd35SMiklos Szeredi
341173a09dd9SAl Viro file->f_mode &= ~FMODE_CREATED;
34126fbd0714SAl Viro dentry = d_lookup(dir, &nd->last);
34136fbd0714SAl Viro for (;;) {
34146fbd0714SAl Viro if (!dentry) {
34156fbd0714SAl Viro dentry = d_alloc_parallel(dir, &nd->last, &wq);
3416d58ffd35SMiklos Szeredi if (IS_ERR(dentry))
3417da5ebf5aSAl Viro return dentry;
34186fbd0714SAl Viro }
34196fbd0714SAl Viro if (d_in_lookup(dentry))
34206fbd0714SAl Viro break;
3421d58ffd35SMiklos Szeredi
34226fbd0714SAl Viro error = d_revalidate(dentry, nd->flags);
34236fbd0714SAl Viro if (likely(error > 0))
34246fbd0714SAl Viro break;
34256fbd0714SAl Viro if (error)
34266fbd0714SAl Viro goto out_dput;
34276fbd0714SAl Viro d_invalidate(dentry);
34286fbd0714SAl Viro dput(dentry);
34296fbd0714SAl Viro dentry = NULL;
34306fbd0714SAl Viro }
34316fbd0714SAl Viro if (dentry->d_inode) {
3432d18e9008SMiklos Szeredi /* Cached positive dentry: will open in f_op->open */
3433da5ebf5aSAl Viro return dentry;
34346c51e513SAl Viro }
3435d18e9008SMiklos Szeredi
34361643b43fSAl Viro /*
34371643b43fSAl Viro * Checking write permission is tricky, bacuse we don't know if we are
34381643b43fSAl Viro * going to actually need it: O_CREAT opens should work as long as the
34391643b43fSAl Viro * file exists. But checking existence breaks atomicity. The trick is
34401643b43fSAl Viro * to check access and if not granted clear O_CREAT from the flags.
34411643b43fSAl Viro *
34421643b43fSAl Viro * Another problem is returing the "right" error value (e.g. for an
34431643b43fSAl Viro * O_EXCL open we want to return EEXIST not EROFS).
34441643b43fSAl Viro */
344599a4a90cSAl Viro if (unlikely(!got_write))
344699a4a90cSAl Viro open_flag &= ~O_TRUNC;
34476c960e68SChristian Brauner idmap = mnt_idmap(nd->path.mnt);
34481643b43fSAl Viro if (open_flag & O_CREAT) {
344999a4a90cSAl Viro if (open_flag & O_EXCL)
345099a4a90cSAl Viro open_flag &= ~O_TRUNC;
34519452e93eSChristian Brauner mode = vfs_prepare_mode(idmap, dir->d_inode, mode, mode, mode);
345299a4a90cSAl Viro if (likely(got_write))
34534609e1f1SChristian Brauner create_error = may_o_create(idmap, &nd->path,
3454ba73d987SChristian Brauner dentry, mode);
345599a4a90cSAl Viro else
345699a4a90cSAl Viro create_error = -EROFS;
345799a4a90cSAl Viro }
345899a4a90cSAl Viro if (create_error)
34591643b43fSAl Viro open_flag &= ~O_CREAT;
34601643b43fSAl Viro if (dir_inode->i_op->atomic_open) {
3461d489cf9aSAl Viro dentry = atomic_open(nd, dentry, file, open_flag, mode);
3462da5ebf5aSAl Viro if (unlikely(create_error) && dentry == ERR_PTR(-ENOENT))
3463da5ebf5aSAl Viro dentry = ERR_PTR(create_error);
3464da5ebf5aSAl Viro return dentry;
3465239eb983SAl Viro }
346654ef4872SMiklos Szeredi
34676fbd0714SAl Viro if (d_in_lookup(dentry)) {
346812fa5e24SAl Viro struct dentry *res = dir_inode->i_op->lookup(dir_inode, dentry,
346912fa5e24SAl Viro nd->flags);
34706fbd0714SAl Viro d_lookup_done(dentry);
347112fa5e24SAl Viro if (unlikely(res)) {
347212fa5e24SAl Viro if (IS_ERR(res)) {
347312fa5e24SAl Viro error = PTR_ERR(res);
347412fa5e24SAl Viro goto out_dput;
347512fa5e24SAl Viro }
347612fa5e24SAl Viro dput(dentry);
347712fa5e24SAl Viro dentry = res;
347812fa5e24SAl Viro }
347954ef4872SMiklos Szeredi }
348054ef4872SMiklos Szeredi
3481d58ffd35SMiklos Szeredi /* Negative dentry, just create the file */
34821643b43fSAl Viro if (!dentry->d_inode && (open_flag & O_CREAT)) {
348373a09dd9SAl Viro file->f_mode |= FMODE_CREATED;
3484ce8644fcSAl Viro audit_inode_child(dir_inode, dentry, AUDIT_TYPE_CHILD_CREATE);
3485ce8644fcSAl Viro if (!dir_inode->i_op->create) {
3486ce8644fcSAl Viro error = -EACCES;
3487d58ffd35SMiklos Szeredi goto out_dput;
348864894cf8SAl Viro }
3489549c7297SChristian Brauner
34906c960e68SChristian Brauner error = dir_inode->i_op->create(idmap, dir_inode, dentry,
3491549c7297SChristian Brauner mode, open_flag & O_EXCL);
3492d58ffd35SMiklos Szeredi if (error)
3493d58ffd35SMiklos Szeredi goto out_dput;
3494d58ffd35SMiklos Szeredi }
34951643b43fSAl Viro if (unlikely(create_error) && !dentry->d_inode) {
34961643b43fSAl Viro error = create_error;
3497d58ffd35SMiklos Szeredi goto out_dput;
3498d58ffd35SMiklos Szeredi }
3499da5ebf5aSAl Viro return dentry;
3500d58ffd35SMiklos Szeredi
3501d58ffd35SMiklos Szeredi out_dput:
3502d58ffd35SMiklos Szeredi dput(dentry);
3503da5ebf5aSAl Viro return ERR_PTR(error);
3504d58ffd35SMiklos Szeredi }
3505d58ffd35SMiklos Szeredi
open_last_lookups(struct nameidata * nd,struct file * file,const struct open_flags * op)3506c981a482SAl Viro static const char *open_last_lookups(struct nameidata *nd,
35073ec2eef1SAl Viro struct file *file, const struct open_flags *op)
3508fb1cc555SAl Viro {
3509a1e28038SAl Viro struct dentry *dir = nd->path.dentry;
3510ca344a89SAl Viro int open_flag = op->open_flag;
351164894cf8SAl Viro bool got_write = false;
3512da5ebf5aSAl Viro struct dentry *dentry;
3513b0417d2cSAl Viro const char *res;
3514fb1cc555SAl Viro
3515c3e380b0SAl Viro nd->flags |= op->intent;
3516c3e380b0SAl Viro
3517bc77daa7SAl Viro if (nd->last_type != LAST_NORM) {
351856676ec3SAl Viro if (nd->depth)
351956676ec3SAl Viro put_link(nd);
3520ff326a32SAl Viro return handle_dots(nd, nd->last_type);
35211f36f774SAl Viro }
3522a2c36b45SAl Viro
3523ca344a89SAl Viro if (!(open_flag & O_CREAT)) {
3524fe2d35ffSAl Viro if (nd->last.name[nd->last.len])
3525fe2d35ffSAl Viro nd->flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
3526fe2d35ffSAl Viro /* we _can_ be in RCU mode here */
35274cb64024SAl Viro dentry = lookup_fast(nd);
352820e34357SAl Viro if (IS_ERR(dentry))
35291ccac622SAl Viro return ERR_CAST(dentry);
353020e34357SAl Viro if (likely(dentry))
353171574865SMiklos Szeredi goto finish_lookup;
353271574865SMiklos Szeredi
35336583fe22SAl Viro BUG_ON(nd->flags & LOOKUP_RCU);
3534b6183df7SMiklos Szeredi } else {
3535fe2d35ffSAl Viro /* create side of things */
353672287417SAl Viro if (nd->flags & LOOKUP_RCU) {
3537e36cffedSJens Axboe if (!try_to_unlazy(nd))
3538e36cffedSJens Axboe return ERR_PTR(-ECHILD);
353972287417SAl Viro }
3540c9b07eabSAl Viro audit_inode(nd->name, dir, AUDIT_INODE_PARENT);
35411f36f774SAl Viro /* trailing slashes? */
3542deb106c6SAl Viro if (unlikely(nd->last.name[nd->last.len]))
35431ccac622SAl Viro return ERR_PTR(-EISDIR);
3544b6183df7SMiklos Szeredi }
35451f36f774SAl Viro
35469cf843e3SAl Viro if (open_flag & (O_CREAT | O_TRUNC | O_WRONLY | O_RDWR)) {
3547e36cffedSJens Axboe got_write = !mnt_want_write(nd->path.mnt);
354864894cf8SAl Viro /*
354964894cf8SAl Viro * do _not_ fail yet - we might not need that or fail with
355064894cf8SAl Viro * a different error; let lookup_open() decide; we'll be
355164894cf8SAl Viro * dropping this one anyway.
355264894cf8SAl Viro */
355364894cf8SAl Viro }
35549cf843e3SAl Viro if (open_flag & O_CREAT)
35555955102cSAl Viro inode_lock(dir->d_inode);
35569cf843e3SAl Viro else
35579cf843e3SAl Viro inode_lock_shared(dir->d_inode);
3558da5ebf5aSAl Viro dentry = lookup_open(nd, file, op, got_write);
3559f7bb959dSAl Viro if (!IS_ERR(dentry) && (file->f_mode & FMODE_CREATED))
3560f7bb959dSAl Viro fsnotify_create(dir->d_inode, dentry);
35619cf843e3SAl Viro if (open_flag & O_CREAT)
35625955102cSAl Viro inode_unlock(dir->d_inode);
35639cf843e3SAl Viro else
35649cf843e3SAl Viro inode_unlock_shared(dir->d_inode);
3565fb1cc555SAl Viro
3566c981a482SAl Viro if (got_write)
356759e96e65SAl Viro mnt_drop_write(nd->path.mnt);
35686c0d46c4SAl Viro
356959e96e65SAl Viro if (IS_ERR(dentry))
357059e96e65SAl Viro return ERR_CAST(dentry);
357159e96e65SAl Viro
3572973d4b73SAl Viro if (file->f_mode & (FMODE_OPENED | FMODE_CREATED)) {
3573e73cabffSAl Viro dput(nd->path.dentry);
3574e73cabffSAl Viro nd->path.dentry = dentry;
3575c981a482SAl Viro return NULL;
3576fb1cc555SAl Viro }
3577fb1cc555SAl Viro
357820e34357SAl Viro finish_lookup:
357956676ec3SAl Viro if (nd->depth)
358056676ec3SAl Viro put_link(nd);
3581a4f5b521SAl Viro res = step_into(nd, WALK_TRAILING, dentry);
3582ff326a32SAl Viro if (unlikely(res))
35831ccac622SAl Viro nd->flags &= ~(LOOKUP_OPEN|LOOKUP_CREATE|LOOKUP_EXCL);
3584b0417d2cSAl Viro return res;
35851ccac622SAl Viro }
358631d1726dSAl Viro
3587c981a482SAl Viro /*
3588c981a482SAl Viro * Handle the last step of open()
3589c981a482SAl Viro */
do_open(struct nameidata * nd,struct file * file,const struct open_flags * op)3590c5971b8cSAl Viro static int do_open(struct nameidata *nd,
3591c981a482SAl Viro struct file *file, const struct open_flags *op)
3592c981a482SAl Viro {
3593abf08576SChristian Brauner struct mnt_idmap *idmap;
3594c981a482SAl Viro int open_flag = op->open_flag;
3595c981a482SAl Viro bool do_truncate;
3596c981a482SAl Viro int acc_mode;
3597c981a482SAl Viro int error;
3598c981a482SAl Viro
3599ff326a32SAl Viro if (!(file->f_mode & (FMODE_OPENED | FMODE_CREATED))) {
3600ff326a32SAl Viro error = complete_walk(nd);
3601ff326a32SAl Viro if (error)
3602ff326a32SAl Viro return error;
3603ff326a32SAl Viro }
3604973d4b73SAl Viro if (!(file->f_mode & FMODE_CREATED))
360576ae2a5aSAl Viro audit_inode(nd->name, nd->path.dentry, 0);
3606abf08576SChristian Brauner idmap = mnt_idmap(nd->path.mnt);
360730aba665SSalvatore Mesoraca if (open_flag & O_CREAT) {
3608b94e0b32SAl Viro if ((open_flag & O_EXCL) && !(file->f_mode & FMODE_CREATED))
3609b94e0b32SAl Viro return -EEXIST;
361030aba665SSalvatore Mesoraca if (d_is_dir(nd->path.dentry))
3611c5971b8cSAl Viro return -EISDIR;
3612e67fe633SChristian Brauner error = may_create_in_sticky(idmap, nd,
361330aba665SSalvatore Mesoraca d_backing_inode(nd->path.dentry));
361430aba665SSalvatore Mesoraca if (unlikely(error))
3615c5971b8cSAl Viro return error;
361630aba665SSalvatore Mesoraca }
361744b1d530SMiklos Szeredi if ((nd->flags & LOOKUP_DIRECTORY) && !d_can_lookup(nd->path.dentry))
3618c5971b8cSAl Viro return -ENOTDIR;
36196c0d46c4SAl Viro
36208795e7d4SAl Viro do_truncate = false;
36218795e7d4SAl Viro acc_mode = op->acc_mode;
36225a2d3eddSAl Viro if (file->f_mode & FMODE_CREATED) {
36235a2d3eddSAl Viro /* Don't check for write permission, don't truncate */
36245a2d3eddSAl Viro open_flag &= ~O_TRUNC;
36255a2d3eddSAl Viro acc_mode = 0;
36268795e7d4SAl Viro } else if (d_is_reg(nd->path.dentry) && open_flag & O_TRUNC) {
36270f9d1a10SAl Viro error = mnt_want_write(nd->path.mnt);
36280f9d1a10SAl Viro if (error)
3629c5971b8cSAl Viro return error;
36308795e7d4SAl Viro do_truncate = true;
36310f9d1a10SAl Viro }
36324609e1f1SChristian Brauner error = may_open(idmap, &nd->path, acc_mode, open_flag);
36338795e7d4SAl Viro if (!error && !(file->f_mode & FMODE_OPENED))
3634ae2bb293SAl Viro error = vfs_open(&nd->path, file);
36358795e7d4SAl Viro if (!error)
36366035a27bSAl Viro error = ima_file_check(file, op->acc_mode);
36378795e7d4SAl Viro if (!error && do_truncate)
3638abf08576SChristian Brauner error = handle_truncate(idmap, file);
3639c80567c8SAl Viro if (unlikely(error > 0)) {
3640c80567c8SAl Viro WARN_ON(1);
3641c80567c8SAl Viro error = -EINVAL;
3642c80567c8SAl Viro }
36438795e7d4SAl Viro if (do_truncate)
36440f9d1a10SAl Viro mnt_drop_write(nd->path.mnt);
3645c5971b8cSAl Viro return error;
3646fb1cc555SAl Viro }
3647fb1cc555SAl Viro
36486521f891SChristian Brauner /**
36496521f891SChristian Brauner * vfs_tmpfile - create tmpfile
3650abf08576SChristian Brauner * @idmap: idmap of the mount the inode was found from
365173bb5a90SRoberto Sassu * @parentpath: pointer to the path of the base directory
365273bb5a90SRoberto Sassu * @file: file descriptor of the new tmpfile
36536521f891SChristian Brauner * @mode: mode of the new tmpfile
36546521f891SChristian Brauner *
36556521f891SChristian Brauner * Create a temporary file.
36566521f891SChristian Brauner *
3657abf08576SChristian Brauner * If the inode has been found through an idmapped mount the idmap of
3658abf08576SChristian Brauner * the vfsmount must be passed through @idmap. This function will then take
3659abf08576SChristian Brauner * care to map the inode according to @idmap before checking permissions.
36606521f891SChristian Brauner * On non-idmapped mounts or if permission checking is to be performed on the
3661abf08576SChristian Brauner * raw inode simply passs @nop_mnt_idmap.
36626521f891SChristian Brauner */
vfs_tmpfile(struct mnt_idmap * idmap,const struct path * parentpath,struct file * file,umode_t mode)3663abf08576SChristian Brauner static int vfs_tmpfile(struct mnt_idmap *idmap,
36649751b338SMiklos Szeredi const struct path *parentpath,
36659751b338SMiklos Szeredi struct file *file, umode_t mode)
3666af7bd4dcSAmir Goldstein {
36679751b338SMiklos Szeredi struct dentry *child;
36689751b338SMiklos Szeredi struct inode *dir = d_inode(parentpath->dentry);
3669af7bd4dcSAmir Goldstein struct inode *inode;
3670af7bd4dcSAmir Goldstein int error;
3671406c706cSPeter Griffin int open_flag = file->f_flags;
3672af7bd4dcSAmir Goldstein
3673af7bd4dcSAmir Goldstein /* we want directory to be writable */
36744609e1f1SChristian Brauner error = inode_permission(idmap, dir, MAY_WRITE | MAY_EXEC);
3675af7bd4dcSAmir Goldstein if (error)
36769751b338SMiklos Szeredi return error;
3677af7bd4dcSAmir Goldstein if (!dir->i_op->tmpfile)
36789751b338SMiklos Szeredi return -EOPNOTSUPP;
36799751b338SMiklos Szeredi child = d_alloc(parentpath->dentry, &slash_name);
3680af7bd4dcSAmir Goldstein if (unlikely(!child))
36819751b338SMiklos Szeredi return -ENOMEM;
36829751b338SMiklos Szeredi file->f_path.mnt = parentpath->mnt;
36839751b338SMiklos Szeredi file->f_path.dentry = child;
36849452e93eSChristian Brauner mode = vfs_prepare_mode(idmap, dir, mode, mode, mode);
3685011e2b71SChristian Brauner error = dir->i_op->tmpfile(idmap, dir, file, mode);
36869751b338SMiklos Szeredi dput(child);
3687af7bd4dcSAmir Goldstein if (error)
36889751b338SMiklos Szeredi return error;
36899751b338SMiklos Szeredi /* Don't check for other permissions, the inode was just created */
36904609e1f1SChristian Brauner error = may_open(idmap, &file->f_path, 0, file->f_flags);
36919751b338SMiklos Szeredi if (error)
36929751b338SMiklos Szeredi return error;
36939751b338SMiklos Szeredi inode = file_inode(file);
3694406c706cSPeter Griffin if (!(open_flag & O_EXCL)) {
3695af7bd4dcSAmir Goldstein spin_lock(&inode->i_lock);
3696af7bd4dcSAmir Goldstein inode->i_state |= I_LINKABLE;
3697af7bd4dcSAmir Goldstein spin_unlock(&inode->i_lock);
3698af7bd4dcSAmir Goldstein }
369939f60c1cSChristian Brauner ima_post_create_tmpfile(idmap, inode);
37009751b338SMiklos Szeredi return 0;
3701af7bd4dcSAmir Goldstein }
3702af7bd4dcSAmir Goldstein
370322873deaSMiklos Szeredi /**
3704d56e0ddbSAmir Goldstein * kernel_tmpfile_open - open a tmpfile for kernel internal use
3705abf08576SChristian Brauner * @idmap: idmap of the mount the inode was found from
370622873deaSMiklos Szeredi * @parentpath: path of the base directory
370722873deaSMiklos Szeredi * @mode: mode of the new tmpfile
370822873deaSMiklos Szeredi * @open_flag: flags
370922873deaSMiklos Szeredi * @cred: credentials for open
371022873deaSMiklos Szeredi *
371122873deaSMiklos Szeredi * Create and open a temporary file. The file is not accounted in nr_files,
371222873deaSMiklos Szeredi * hence this is only for kernel internal use, and must not be installed into
371322873deaSMiklos Szeredi * file tables or such.
371422873deaSMiklos Szeredi */
kernel_tmpfile_open(struct mnt_idmap * idmap,const struct path * parentpath,umode_t mode,int open_flag,const struct cred * cred)3715d56e0ddbSAmir Goldstein struct file *kernel_tmpfile_open(struct mnt_idmap *idmap,
371622873deaSMiklos Szeredi const struct path *parentpath,
3717d56e0ddbSAmir Goldstein umode_t mode, int open_flag,
3718d56e0ddbSAmir Goldstein const struct cred *cred)
371922873deaSMiklos Szeredi {
372022873deaSMiklos Szeredi struct file *file;
372122873deaSMiklos Szeredi int error;
372222873deaSMiklos Szeredi
37239751b338SMiklos Szeredi file = alloc_empty_file_noaccount(open_flag, cred);
3724d56e0ddbSAmir Goldstein if (IS_ERR(file))
3725d56e0ddbSAmir Goldstein return file;
3726d56e0ddbSAmir Goldstein
3727abf08576SChristian Brauner error = vfs_tmpfile(idmap, parentpath, file, mode);
37289751b338SMiklos Szeredi if (error) {
37299751b338SMiklos Szeredi fput(file);
373022873deaSMiklos Szeredi file = ERR_PTR(error);
37319751b338SMiklos Szeredi }
373222873deaSMiklos Szeredi return file;
373322873deaSMiklos Szeredi }
3734d56e0ddbSAmir Goldstein EXPORT_SYMBOL(kernel_tmpfile_open);
3735648fa861SAl Viro
do_tmpfile(struct nameidata * nd,unsigned flags,const struct open_flags * op,struct file * file)3736c8a53ee5SAl Viro static int do_tmpfile(struct nameidata *nd, unsigned flags,
373760545d0dSAl Viro const struct open_flags *op,
37383ec2eef1SAl Viro struct file *file)
373960545d0dSAl Viro {
3740625b6d10SAl Viro struct path path;
3741c8a53ee5SAl Viro int error = path_lookupat(nd, flags | LOOKUP_DIRECTORY, &path);
37429751b338SMiklos Szeredi
374360545d0dSAl Viro if (unlikely(error))
374460545d0dSAl Viro return error;
3745625b6d10SAl Viro error = mnt_want_write(path.mnt);
374660545d0dSAl Viro if (unlikely(error))
374760545d0dSAl Viro goto out;
3748abf08576SChristian Brauner error = vfs_tmpfile(mnt_idmap(path.mnt), &path, file, op->mode);
37499751b338SMiklos Szeredi if (error)
375060545d0dSAl Viro goto out2;
37519751b338SMiklos Szeredi audit_inode(nd->name, file->f_path.dentry, 0);
375260545d0dSAl Viro out2:
3753625b6d10SAl Viro mnt_drop_write(path.mnt);
375460545d0dSAl Viro out:
3755625b6d10SAl Viro path_put(&path);
375660545d0dSAl Viro return error;
375760545d0dSAl Viro }
375860545d0dSAl Viro
do_o_path(struct nameidata * nd,unsigned flags,struct file * file)37596ac08709SAl Viro static int do_o_path(struct nameidata *nd, unsigned flags, struct file *file)
37606ac08709SAl Viro {
37616ac08709SAl Viro struct path path;
37626ac08709SAl Viro int error = path_lookupat(nd, flags, &path);
37636ac08709SAl Viro if (!error) {
37646ac08709SAl Viro audit_inode(nd->name, path.dentry, 0);
3765ae2bb293SAl Viro error = vfs_open(&path, file);
37666ac08709SAl Viro path_put(&path);
37676ac08709SAl Viro }
37686ac08709SAl Viro return error;
37696ac08709SAl Viro }
37706ac08709SAl Viro
path_openat(struct nameidata * nd,const struct open_flags * op,unsigned flags)3771c8a53ee5SAl Viro static struct file *path_openat(struct nameidata *nd,
3772c8a53ee5SAl Viro const struct open_flags *op, unsigned flags)
37731da177e4SLinus Torvalds {
377430d90494SAl Viro struct file *file;
377513aab428SAl Viro int error;
377631e6b01fSNick Piggin
3777ea73ea72SAl Viro file = alloc_empty_file(op->open_flag, current_cred());
37781afc99beSAl Viro if (IS_ERR(file))
37791afc99beSAl Viro return file;
378031e6b01fSNick Piggin
3781bb458c64SAl Viro if (unlikely(file->f_flags & __O_TMPFILE)) {
37823ec2eef1SAl Viro error = do_tmpfile(nd, flags, op, file);
37835f336e72SAl Viro } else if (unlikely(file->f_flags & O_PATH)) {
37846ac08709SAl Viro error = do_o_path(nd, flags, file);
37855f336e72SAl Viro } else {
37865f336e72SAl Viro const char *s = path_init(nd, flags);
37873bdba28bSAl Viro while (!(error = link_path_walk(s, nd)) &&
3788c5971b8cSAl Viro (s = open_last_lookups(nd, file, op)) != NULL)
37891ccac622SAl Viro ;
3790c5971b8cSAl Viro if (!error)
3791c5971b8cSAl Viro error = do_open(nd, file, op);
3792deb106c6SAl Viro terminate_walk(nd);
37935f336e72SAl Viro }
37947c1c01ecSAl Viro if (likely(!error)) {
3795aad888f8SAl Viro if (likely(file->f_mode & FMODE_OPENED))
37967c1c01ecSAl Viro return file;
37977c1c01ecSAl Viro WARN_ON(1);
37987c1c01ecSAl Viro error = -EINVAL;
3799015c3bbcSMiklos Szeredi }
38007c1c01ecSAl Viro fput(file);
38012675a4ebSAl Viro if (error == -EOPENSTALE) {
38022675a4ebSAl Viro if (flags & LOOKUP_RCU)
38032675a4ebSAl Viro error = -ECHILD;
38042675a4ebSAl Viro else
38052675a4ebSAl Viro error = -ESTALE;
38062675a4ebSAl Viro }
38077c1c01ecSAl Viro return ERR_PTR(error);
3808de459215SKirill Korotaev }
38091da177e4SLinus Torvalds
do_filp_open(int dfd,struct filename * pathname,const struct open_flags * op)3810669abf4eSJeff Layton struct file *do_filp_open(int dfd, struct filename *pathname,
3811f9652e10SAl Viro const struct open_flags *op)
381213aab428SAl Viro {
38139883d185SAl Viro struct nameidata nd;
3814f9652e10SAl Viro int flags = op->lookup_flags;
381513aab428SAl Viro struct file *filp;
381613aab428SAl Viro
381706422964SAl Viro set_nameidata(&nd, dfd, pathname, NULL);
3818c8a53ee5SAl Viro filp = path_openat(&nd, op, flags | LOOKUP_RCU);
381913aab428SAl Viro if (unlikely(filp == ERR_PTR(-ECHILD)))
3820c8a53ee5SAl Viro filp = path_openat(&nd, op, flags);
382113aab428SAl Viro if (unlikely(filp == ERR_PTR(-ESTALE)))
3822c8a53ee5SAl Viro filp = path_openat(&nd, op, flags | LOOKUP_REVAL);
38239883d185SAl Viro restore_nameidata();
382413aab428SAl Viro return filp;
382513aab428SAl Viro }
382613aab428SAl Viro
do_file_open_root(const struct path * root,const char * name,const struct open_flags * op)3827ffb37ca3SAl Viro struct file *do_file_open_root(const struct path *root,
3828f9652e10SAl Viro const char *name, const struct open_flags *op)
382973d049a4SAl Viro {
38309883d185SAl Viro struct nameidata nd;
383173d049a4SAl Viro struct file *file;
383251689104SPaul Moore struct filename *filename;
3833bcba1e7dSAl Viro int flags = op->lookup_flags;
383473d049a4SAl Viro
3835ffb37ca3SAl Viro if (d_is_symlink(root->dentry) && op->intent & LOOKUP_OPEN)
383673d049a4SAl Viro return ERR_PTR(-ELOOP);
383773d049a4SAl Viro
383851689104SPaul Moore filename = getname_kernel(name);
3839a1c83681SViresh Kumar if (IS_ERR(filename))
384051689104SPaul Moore return ERR_CAST(filename);
384151689104SPaul Moore
384206422964SAl Viro set_nameidata(&nd, -1, filename, root);
3843c8a53ee5SAl Viro file = path_openat(&nd, op, flags | LOOKUP_RCU);
384473d049a4SAl Viro if (unlikely(file == ERR_PTR(-ECHILD)))
3845c8a53ee5SAl Viro file = path_openat(&nd, op, flags);
384673d049a4SAl Viro if (unlikely(file == ERR_PTR(-ESTALE)))
3847c8a53ee5SAl Viro file = path_openat(&nd, op, flags | LOOKUP_REVAL);
38489883d185SAl Viro restore_nameidata();
384951689104SPaul Moore putname(filename);
385073d049a4SAl Viro return file;
385173d049a4SAl Viro }
385273d049a4SAl Viro
filename_create(int dfd,struct filename * name,struct path * path,unsigned int lookup_flags)3853b4a4f213SStephen Brennan static struct dentry *filename_create(int dfd, struct filename *name,
38541ac12b4bSJeff Layton struct path *path, unsigned int lookup_flags)
38551da177e4SLinus Torvalds {
3856c663e5d8SChristoph Hellwig struct dentry *dentry = ERR_PTR(-EEXIST);
3857391172c4SAl Viro struct qstr last;
3858b3d4650dSNeilBrown bool want_dir = lookup_flags & LOOKUP_DIRECTORY;
3859b3d4650dSNeilBrown unsigned int reval_flag = lookup_flags & LOOKUP_REVAL;
3860b3d4650dSNeilBrown unsigned int create_flags = LOOKUP_CREATE | LOOKUP_EXCL;
3861391172c4SAl Viro int type;
3862c30dabfeSJan Kara int err2;
38631ac12b4bSJeff Layton int error;
38641ac12b4bSJeff Layton
3865b3d4650dSNeilBrown error = filename_parentat(dfd, name, reval_flag, path, &last, &type);
38660ee50b47SDmitry Kadashev if (error)
38670ee50b47SDmitry Kadashev return ERR_PTR(error);
38681da177e4SLinus Torvalds
3869c663e5d8SChristoph Hellwig /*
3870c663e5d8SChristoph Hellwig * Yucky last component or no last component at all?
3871c663e5d8SChristoph Hellwig * (foo/., foo/.., /////)
3872c663e5d8SChristoph Hellwig */
38735c31b6ceSAl Viro if (unlikely(type != LAST_NORM))
3874ed75e95dSAl Viro goto out;
3875c663e5d8SChristoph Hellwig
3876c30dabfeSJan Kara /* don't fail immediately if it's r/o, at least try to report other errors */
3877391172c4SAl Viro err2 = mnt_want_write(path->mnt);
3878c663e5d8SChristoph Hellwig /*
3879b3d4650dSNeilBrown * Do the final lookup. Suppress 'create' if there is a trailing
3880b3d4650dSNeilBrown * '/', and a directory wasn't requested.
3881c663e5d8SChristoph Hellwig */
3882b3d4650dSNeilBrown if (last.name[last.len] && !want_dir)
3883b3d4650dSNeilBrown create_flags = 0;
38845955102cSAl Viro inode_lock_nested(path->dentry->d_inode, I_MUTEX_PARENT);
388574d7970fSNamjae Jeon dentry = lookup_one_qstr_excl(&last, path->dentry,
388674d7970fSNamjae Jeon reval_flag | create_flags);
38871da177e4SLinus Torvalds if (IS_ERR(dentry))
3888a8104a9fSAl Viro goto unlock;
3889c663e5d8SChristoph Hellwig
3890a8104a9fSAl Viro error = -EEXIST;
3891b18825a7SDavid Howells if (d_is_positive(dentry))
3892a8104a9fSAl Viro goto fail;
3893b18825a7SDavid Howells
3894c663e5d8SChristoph Hellwig /*
3895c663e5d8SChristoph Hellwig * Special case - lookup gave negative, but... we had foo/bar/
3896c663e5d8SChristoph Hellwig * From the vfs_mknod() POV we just have a negative dentry -
3897c663e5d8SChristoph Hellwig * all is fine. Let's be bastards - you had / on the end, you've
3898c663e5d8SChristoph Hellwig * been asking for (non-existent) directory. -ENOENT for you.
3899c663e5d8SChristoph Hellwig */
3900b3d4650dSNeilBrown if (unlikely(!create_flags)) {
3901a8104a9fSAl Viro error = -ENOENT;
3902ed75e95dSAl Viro goto fail;
3903e9baf6e5SAl Viro }
3904c30dabfeSJan Kara if (unlikely(err2)) {
3905c30dabfeSJan Kara error = err2;
3906a8104a9fSAl Viro goto fail;
3907c30dabfeSJan Kara }
3908e9baf6e5SAl Viro return dentry;
39091da177e4SLinus Torvalds fail:
3910a8104a9fSAl Viro dput(dentry);
3911a8104a9fSAl Viro dentry = ERR_PTR(error);
3912a8104a9fSAl Viro unlock:
39135955102cSAl Viro inode_unlock(path->dentry->d_inode);
3914c30dabfeSJan Kara if (!err2)
3915391172c4SAl Viro mnt_drop_write(path->mnt);
3916ed75e95dSAl Viro out:
3917391172c4SAl Viro path_put(path);
3918ed75e95dSAl Viro return dentry;
3919dae6ad8fSAl Viro }
3920fa14a0b8SAl Viro
kern_path_create(int dfd,const char * pathname,struct path * path,unsigned int lookup_flags)3921fa14a0b8SAl Viro struct dentry *kern_path_create(int dfd, const char *pathname,
3922fa14a0b8SAl Viro struct path *path, unsigned int lookup_flags)
3923fa14a0b8SAl Viro {
3924b4a4f213SStephen Brennan struct filename *filename = getname_kernel(pathname);
3925b4a4f213SStephen Brennan struct dentry *res = filename_create(dfd, filename, path, lookup_flags);
3926b4a4f213SStephen Brennan
3927b4a4f213SStephen Brennan putname(filename);
3928b4a4f213SStephen Brennan return res;
3929fa14a0b8SAl Viro }
3930dae6ad8fSAl Viro EXPORT_SYMBOL(kern_path_create);
3931dae6ad8fSAl Viro
done_path_create(struct path * path,struct dentry * dentry)3932921a1650SAl Viro void done_path_create(struct path *path, struct dentry *dentry)
3933921a1650SAl Viro {
3934921a1650SAl Viro dput(dentry);
39355955102cSAl Viro inode_unlock(path->dentry->d_inode);
3936a8104a9fSAl Viro mnt_drop_write(path->mnt);
3937921a1650SAl Viro path_put(path);
3938921a1650SAl Viro }
3939921a1650SAl Viro EXPORT_SYMBOL(done_path_create);
3940921a1650SAl Viro
user_path_create(int dfd,const char __user * pathname,struct path * path,unsigned int lookup_flags)3941520ae687SAl Viro inline struct dentry *user_path_create(int dfd, const char __user *pathname,
39421ac12b4bSJeff Layton struct path *path, unsigned int lookup_flags)
3943dae6ad8fSAl Viro {
3944b4a4f213SStephen Brennan struct filename *filename = getname(pathname);
3945b4a4f213SStephen Brennan struct dentry *res = filename_create(dfd, filename, path, lookup_flags);
3946b4a4f213SStephen Brennan
3947b4a4f213SStephen Brennan putname(filename);
3948b4a4f213SStephen Brennan return res;
3949dae6ad8fSAl Viro }
3950dae6ad8fSAl Viro EXPORT_SYMBOL(user_path_create);
3951dae6ad8fSAl Viro
39526521f891SChristian Brauner /**
39536521f891SChristian Brauner * vfs_mknod - create device node or file
3954abf08576SChristian Brauner * @idmap: idmap of the mount the inode was found from
39556521f891SChristian Brauner * @dir: inode of @dentry
39566521f891SChristian Brauner * @dentry: pointer to dentry of the base directory
39576521f891SChristian Brauner * @mode: mode of the new device node or file
39586521f891SChristian Brauner * @dev: device number of device to create
39596521f891SChristian Brauner *
39606521f891SChristian Brauner * Create a device node or file.
39616521f891SChristian Brauner *
3962abf08576SChristian Brauner * If the inode has been found through an idmapped mount the idmap of
3963abf08576SChristian Brauner * the vfsmount must be passed through @idmap. This function will then take
3964abf08576SChristian Brauner * care to map the inode according to @idmap before checking permissions.
39656521f891SChristian Brauner * On non-idmapped mounts or if permission checking is to be performed on the
3966abf08576SChristian Brauner * raw inode simply passs @nop_mnt_idmap.
39676521f891SChristian Brauner */
vfs_mknod(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry,umode_t mode,dev_t dev)3968abf08576SChristian Brauner int vfs_mknod(struct mnt_idmap *idmap, struct inode *dir,
39696521f891SChristian Brauner struct dentry *dentry, umode_t mode, dev_t dev)
39701da177e4SLinus Torvalds {
3971a3c751a5SMiklos Szeredi bool is_whiteout = S_ISCHR(mode) && dev == WHITEOUT_DEV;
39724609e1f1SChristian Brauner int error = may_create(idmap, dir, dentry);
39731da177e4SLinus Torvalds
39741da177e4SLinus Torvalds if (error)
39751da177e4SLinus Torvalds return error;
39761da177e4SLinus Torvalds
3977a3c751a5SMiklos Szeredi if ((S_ISCHR(mode) || S_ISBLK(mode)) && !is_whiteout &&
3978a3c751a5SMiklos Szeredi !capable(CAP_MKNOD))
39791da177e4SLinus Torvalds return -EPERM;
39801da177e4SLinus Torvalds
3981acfa4380SAl Viro if (!dir->i_op->mknod)
39821da177e4SLinus Torvalds return -EPERM;
39831da177e4SLinus Torvalds
39849452e93eSChristian Brauner mode = vfs_prepare_mode(idmap, dir, mode, mode, mode);
398508ce5f16SSerge E. Hallyn error = devcgroup_inode_mknod(mode, dev);
398608ce5f16SSerge E. Hallyn if (error)
398708ce5f16SSerge E. Hallyn return error;
398808ce5f16SSerge E. Hallyn
39891da177e4SLinus Torvalds error = security_inode_mknod(dir, dentry, mode, dev);
39901da177e4SLinus Torvalds if (error)
39911da177e4SLinus Torvalds return error;
39921da177e4SLinus Torvalds
39935ebb29beSChristian Brauner error = dir->i_op->mknod(idmap, dir, dentry, mode, dev);
3994a74574aaSStephen Smalley if (!error)
3995f38aa942SAmy Griffis fsnotify_create(dir, dentry);
39961da177e4SLinus Torvalds return error;
39971da177e4SLinus Torvalds }
39984d359507SAl Viro EXPORT_SYMBOL(vfs_mknod);
39991da177e4SLinus Torvalds
may_mknod(umode_t mode)4000f69aac00SAl Viro static int may_mknod(umode_t mode)
4001463c3197SDave Hansen {
4002463c3197SDave Hansen switch (mode & S_IFMT) {
4003463c3197SDave Hansen case S_IFREG:
4004463c3197SDave Hansen case S_IFCHR:
4005463c3197SDave Hansen case S_IFBLK:
4006463c3197SDave Hansen case S_IFIFO:
4007463c3197SDave Hansen case S_IFSOCK:
4008463c3197SDave Hansen case 0: /* zero mode translates to S_IFREG */
4009463c3197SDave Hansen return 0;
4010463c3197SDave Hansen case S_IFDIR:
4011463c3197SDave Hansen return -EPERM;
4012463c3197SDave Hansen default:
4013463c3197SDave Hansen return -EINVAL;
4014463c3197SDave Hansen }
4015463c3197SDave Hansen }
4016463c3197SDave Hansen
do_mknodat(int dfd,struct filename * name,umode_t mode,unsigned int dev)401745f30dabSDmitry Kadashev static int do_mknodat(int dfd, struct filename *name, umode_t mode,
401887c4e192SDominik Brodowski unsigned int dev)
40191da177e4SLinus Torvalds {
4020abf08576SChristian Brauner struct mnt_idmap *idmap;
40211da177e4SLinus Torvalds struct dentry *dentry;
4022dae6ad8fSAl Viro struct path path;
4023dae6ad8fSAl Viro int error;
4024972567f1SJeff Layton unsigned int lookup_flags = 0;
40251da177e4SLinus Torvalds
40268e4bfca1SAl Viro error = may_mknod(mode);
40278e4bfca1SAl Viro if (error)
40287797251bSDmitry Kadashev goto out1;
4029972567f1SJeff Layton retry:
4030b4a4f213SStephen Brennan dentry = filename_create(dfd, name, &path, lookup_flags);
40317797251bSDmitry Kadashev error = PTR_ERR(dentry);
4032dae6ad8fSAl Viro if (IS_ERR(dentry))
40337797251bSDmitry Kadashev goto out1;
40342ad94ae6SAl Viro
40351639a49cSYang Xu error = security_path_mknod(&path, dentry,
40361639a49cSYang Xu mode_strip_umask(path.dentry->d_inode, mode), dev);
4037be6d3e56SKentaro Takeda if (error)
40387797251bSDmitry Kadashev goto out2;
40396521f891SChristian Brauner
4040abf08576SChristian Brauner idmap = mnt_idmap(path.mnt);
40411da177e4SLinus Torvalds switch (mode & S_IFMT) {
40421da177e4SLinus Torvalds case 0: case S_IFREG:
4043abf08576SChristian Brauner error = vfs_create(idmap, path.dentry->d_inode,
40446521f891SChristian Brauner dentry, mode, true);
404505d1a717SMimi Zohar if (!error)
404639f60c1cSChristian Brauner ima_post_path_mknod(idmap, dentry);
40471da177e4SLinus Torvalds break;
40481da177e4SLinus Torvalds case S_IFCHR: case S_IFBLK:
4049abf08576SChristian Brauner error = vfs_mknod(idmap, path.dentry->d_inode,
40506521f891SChristian Brauner dentry, mode, new_decode_dev(dev));
40511da177e4SLinus Torvalds break;
40521da177e4SLinus Torvalds case S_IFIFO: case S_IFSOCK:
4053abf08576SChristian Brauner error = vfs_mknod(idmap, path.dentry->d_inode,
40546521f891SChristian Brauner dentry, mode, 0);
40551da177e4SLinus Torvalds break;
40561da177e4SLinus Torvalds }
40577797251bSDmitry Kadashev out2:
4058921a1650SAl Viro done_path_create(&path, dentry);
4059972567f1SJeff Layton if (retry_estale(error, lookup_flags)) {
4060972567f1SJeff Layton lookup_flags |= LOOKUP_REVAL;
4061972567f1SJeff Layton goto retry;
4062972567f1SJeff Layton }
40637797251bSDmitry Kadashev out1:
40647797251bSDmitry Kadashev putname(name);
40651da177e4SLinus Torvalds return error;
40661da177e4SLinus Torvalds }
40671da177e4SLinus Torvalds
SYSCALL_DEFINE4(mknodat,int,dfd,const char __user *,filename,umode_t,mode,unsigned int,dev)406887c4e192SDominik Brodowski SYSCALL_DEFINE4(mknodat, int, dfd, const char __user *, filename, umode_t, mode,
406987c4e192SDominik Brodowski unsigned int, dev)
407087c4e192SDominik Brodowski {
40717797251bSDmitry Kadashev return do_mknodat(dfd, getname(filename), mode, dev);
407287c4e192SDominik Brodowski }
407387c4e192SDominik Brodowski
SYSCALL_DEFINE3(mknod,const char __user *,filename,umode_t,mode,unsigned,dev)40748208a22bSAl Viro SYSCALL_DEFINE3(mknod, const char __user *, filename, umode_t, mode, unsigned, dev)
40755590ff0dSUlrich Drepper {
40767797251bSDmitry Kadashev return do_mknodat(AT_FDCWD, getname(filename), mode, dev);
40775590ff0dSUlrich Drepper }
40785590ff0dSUlrich Drepper
40796521f891SChristian Brauner /**
40806521f891SChristian Brauner * vfs_mkdir - create directory
4081abf08576SChristian Brauner * @idmap: idmap of the mount the inode was found from
40826521f891SChristian Brauner * @dir: inode of @dentry
40836521f891SChristian Brauner * @dentry: pointer to dentry of the base directory
40846521f891SChristian Brauner * @mode: mode of the new directory
40856521f891SChristian Brauner *
40866521f891SChristian Brauner * Create a directory.
40876521f891SChristian Brauner *
4088abf08576SChristian Brauner * If the inode has been found through an idmapped mount the idmap of
4089abf08576SChristian Brauner * the vfsmount must be passed through @idmap. This function will then take
4090abf08576SChristian Brauner * care to map the inode according to @idmap before checking permissions.
40916521f891SChristian Brauner * On non-idmapped mounts or if permission checking is to be performed on the
4092abf08576SChristian Brauner * raw inode simply passs @nop_mnt_idmap.
40936521f891SChristian Brauner */
vfs_mkdir(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry,umode_t mode)4094abf08576SChristian Brauner int vfs_mkdir(struct mnt_idmap *idmap, struct inode *dir,
40956521f891SChristian Brauner struct dentry *dentry, umode_t mode)
40961da177e4SLinus Torvalds {
4097abf08576SChristian Brauner int error;
40988de52778SAl Viro unsigned max_links = dir->i_sb->s_max_links;
40991da177e4SLinus Torvalds
41004609e1f1SChristian Brauner error = may_create(idmap, dir, dentry);
41011da177e4SLinus Torvalds if (error)
41021da177e4SLinus Torvalds return error;
41031da177e4SLinus Torvalds
4104acfa4380SAl Viro if (!dir->i_op->mkdir)
41051da177e4SLinus Torvalds return -EPERM;
41061da177e4SLinus Torvalds
41079452e93eSChristian Brauner mode = vfs_prepare_mode(idmap, dir, mode, S_IRWXUGO | S_ISVTX, 0);
41081da177e4SLinus Torvalds error = security_inode_mkdir(dir, dentry, mode);
41091da177e4SLinus Torvalds if (error)
41101da177e4SLinus Torvalds return error;
41111da177e4SLinus Torvalds
41128de52778SAl Viro if (max_links && dir->i_nlink >= max_links)
41138de52778SAl Viro return -EMLINK;
41148de52778SAl Viro
4115c54bd91eSChristian Brauner error = dir->i_op->mkdir(idmap, dir, dentry, mode);
4116a74574aaSStephen Smalley if (!error)
4117f38aa942SAmy Griffis fsnotify_mkdir(dir, dentry);
41181da177e4SLinus Torvalds return error;
41191da177e4SLinus Torvalds }
41204d359507SAl Viro EXPORT_SYMBOL(vfs_mkdir);
41211da177e4SLinus Torvalds
do_mkdirat(int dfd,struct filename * name,umode_t mode)412245f30dabSDmitry Kadashev int do_mkdirat(int dfd, struct filename *name, umode_t mode)
41231da177e4SLinus Torvalds {
41246902d925SDave Hansen struct dentry *dentry;
4125dae6ad8fSAl Viro struct path path;
4126dae6ad8fSAl Viro int error;
4127b76d8b82SJeff Layton unsigned int lookup_flags = LOOKUP_DIRECTORY;
41281da177e4SLinus Torvalds
4129b76d8b82SJeff Layton retry:
4130b4a4f213SStephen Brennan dentry = filename_create(dfd, name, &path, lookup_flags);
4131584d3226SDmitry Kadashev error = PTR_ERR(dentry);
41326902d925SDave Hansen if (IS_ERR(dentry))
4133584d3226SDmitry Kadashev goto out_putname;
41346902d925SDave Hansen
41351639a49cSYang Xu error = security_path_mkdir(&path, dentry,
41361639a49cSYang Xu mode_strip_umask(path.dentry->d_inode, mode));
41376521f891SChristian Brauner if (!error) {
4138abf08576SChristian Brauner error = vfs_mkdir(mnt_idmap(path.mnt), path.dentry->d_inode,
4139abf08576SChristian Brauner dentry, mode);
41406521f891SChristian Brauner }
4141921a1650SAl Viro done_path_create(&path, dentry);
4142b76d8b82SJeff Layton if (retry_estale(error, lookup_flags)) {
4143b76d8b82SJeff Layton lookup_flags |= LOOKUP_REVAL;
4144b76d8b82SJeff Layton goto retry;
4145b76d8b82SJeff Layton }
4146584d3226SDmitry Kadashev out_putname:
4147584d3226SDmitry Kadashev putname(name);
41481da177e4SLinus Torvalds return error;
41491da177e4SLinus Torvalds }
41501da177e4SLinus Torvalds
SYSCALL_DEFINE3(mkdirat,int,dfd,const char __user *,pathname,umode_t,mode)41510101db7aSDominik Brodowski SYSCALL_DEFINE3(mkdirat, int, dfd, const char __user *, pathname, umode_t, mode)
41520101db7aSDominik Brodowski {
4153584d3226SDmitry Kadashev return do_mkdirat(dfd, getname(pathname), mode);
41540101db7aSDominik Brodowski }
41550101db7aSDominik Brodowski
SYSCALL_DEFINE2(mkdir,const char __user *,pathname,umode_t,mode)4156a218d0fdSAl Viro SYSCALL_DEFINE2(mkdir, const char __user *, pathname, umode_t, mode)
41575590ff0dSUlrich Drepper {
4158584d3226SDmitry Kadashev return do_mkdirat(AT_FDCWD, getname(pathname), mode);
41595590ff0dSUlrich Drepper }
41605590ff0dSUlrich Drepper
41616521f891SChristian Brauner /**
41626521f891SChristian Brauner * vfs_rmdir - remove directory
4163abf08576SChristian Brauner * @idmap: idmap of the mount the inode was found from
41646521f891SChristian Brauner * @dir: inode of @dentry
41656521f891SChristian Brauner * @dentry: pointer to dentry of the base directory
41666521f891SChristian Brauner *
41676521f891SChristian Brauner * Remove a directory.
41686521f891SChristian Brauner *
4169abf08576SChristian Brauner * If the inode has been found through an idmapped mount the idmap of
4170abf08576SChristian Brauner * the vfsmount must be passed through @idmap. This function will then take
4171abf08576SChristian Brauner * care to map the inode according to @idmap before checking permissions.
41726521f891SChristian Brauner * On non-idmapped mounts or if permission checking is to be performed on the
4173abf08576SChristian Brauner * raw inode simply passs @nop_mnt_idmap.
41746521f891SChristian Brauner */
vfs_rmdir(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry)4175abf08576SChristian Brauner int vfs_rmdir(struct mnt_idmap *idmap, struct inode *dir,
41766521f891SChristian Brauner struct dentry *dentry)
41771da177e4SLinus Torvalds {
41784609e1f1SChristian Brauner int error = may_delete(idmap, dir, dentry, 1);
41791da177e4SLinus Torvalds
41801da177e4SLinus Torvalds if (error)
41811da177e4SLinus Torvalds return error;
41821da177e4SLinus Torvalds
4183acfa4380SAl Viro if (!dir->i_op->rmdir)
41841da177e4SLinus Torvalds return -EPERM;
41851da177e4SLinus Torvalds
41861d2ef590SAl Viro dget(dentry);
41875955102cSAl Viro inode_lock(dentry->d_inode);
4188912dbc15SSage Weil
41891da177e4SLinus Torvalds error = -EBUSY;
41901bd9c4e4SDavid Howells if (is_local_mountpoint(dentry) ||
41911bd9c4e4SDavid Howells (dentry->d_inode->i_flags & S_KERNEL_FILE))
4192912dbc15SSage Weil goto out;
4193912dbc15SSage Weil
41941da177e4SLinus Torvalds error = security_inode_rmdir(dir, dentry);
4195912dbc15SSage Weil if (error)
4196912dbc15SSage Weil goto out;
4197912dbc15SSage Weil
41981da177e4SLinus Torvalds error = dir->i_op->rmdir(dir, dentry);
4199912dbc15SSage Weil if (error)
4200912dbc15SSage Weil goto out;
4201912dbc15SSage Weil
42028767712fSAl Viro shrink_dcache_parent(dentry);
42031da177e4SLinus Torvalds dentry->d_inode->i_flags |= S_DEAD;
4204d83c49f3SAl Viro dont_mount(dentry);
42058ed936b5SEric W. Biederman detach_mounts(dentry);
42061da177e4SLinus Torvalds
4207912dbc15SSage Weil out:
42085955102cSAl Viro inode_unlock(dentry->d_inode);
42091d2ef590SAl Viro dput(dentry);
4210912dbc15SSage Weil if (!error)
4211a37d9a17SAmir Goldstein d_delete_notify(dir, dentry);
42121da177e4SLinus Torvalds return error;
42131da177e4SLinus Torvalds }
42144d359507SAl Viro EXPORT_SYMBOL(vfs_rmdir);
42151da177e4SLinus Torvalds
do_rmdir(int dfd,struct filename * name)421645f30dabSDmitry Kadashev int do_rmdir(int dfd, struct filename *name)
42171da177e4SLinus Torvalds {
42180ee50b47SDmitry Kadashev int error;
42191da177e4SLinus Torvalds struct dentry *dentry;
4220f5beed75SAl Viro struct path path;
4221f5beed75SAl Viro struct qstr last;
4222f5beed75SAl Viro int type;
4223c6ee9206SJeff Layton unsigned int lookup_flags = 0;
4224c6ee9206SJeff Layton retry:
4225c5f563f9SAl Viro error = filename_parentat(dfd, name, lookup_flags, &path, &last, &type);
42260ee50b47SDmitry Kadashev if (error)
42270ee50b47SDmitry Kadashev goto exit1;
42281da177e4SLinus Torvalds
4229f5beed75SAl Viro switch (type) {
42301da177e4SLinus Torvalds case LAST_DOTDOT:
42311da177e4SLinus Torvalds error = -ENOTEMPTY;
42320ee50b47SDmitry Kadashev goto exit2;
42331da177e4SLinus Torvalds case LAST_DOT:
42341da177e4SLinus Torvalds error = -EINVAL;
42350ee50b47SDmitry Kadashev goto exit2;
42361da177e4SLinus Torvalds case LAST_ROOT:
42371da177e4SLinus Torvalds error = -EBUSY;
42380ee50b47SDmitry Kadashev goto exit2;
42391da177e4SLinus Torvalds }
42400612d9fbSOGAWA Hirofumi
4241f5beed75SAl Viro error = mnt_want_write(path.mnt);
4242c30dabfeSJan Kara if (error)
42430ee50b47SDmitry Kadashev goto exit2;
42440612d9fbSOGAWA Hirofumi
42455955102cSAl Viro inode_lock_nested(path.dentry->d_inode, I_MUTEX_PARENT);
424674d7970fSNamjae Jeon dentry = lookup_one_qstr_excl(&last, path.dentry, lookup_flags);
42471da177e4SLinus Torvalds error = PTR_ERR(dentry);
42486902d925SDave Hansen if (IS_ERR(dentry))
42490ee50b47SDmitry Kadashev goto exit3;
4250e6bc45d6STheodore Ts'o if (!dentry->d_inode) {
4251e6bc45d6STheodore Ts'o error = -ENOENT;
42520ee50b47SDmitry Kadashev goto exit4;
4253e6bc45d6STheodore Ts'o }
4254f5beed75SAl Viro error = security_path_rmdir(&path, dentry);
4255be6d3e56SKentaro Takeda if (error)
42560ee50b47SDmitry Kadashev goto exit4;
4257abf08576SChristian Brauner error = vfs_rmdir(mnt_idmap(path.mnt), path.dentry->d_inode, dentry);
42580ee50b47SDmitry Kadashev exit4:
42591da177e4SLinus Torvalds dput(dentry);
42600ee50b47SDmitry Kadashev exit3:
42615955102cSAl Viro inode_unlock(path.dentry->d_inode);
4262f5beed75SAl Viro mnt_drop_write(path.mnt);
42630ee50b47SDmitry Kadashev exit2:
4264f5beed75SAl Viro path_put(&path);
4265c6ee9206SJeff Layton if (retry_estale(error, lookup_flags)) {
4266c6ee9206SJeff Layton lookup_flags |= LOOKUP_REVAL;
4267c6ee9206SJeff Layton goto retry;
4268c6ee9206SJeff Layton }
42690ee50b47SDmitry Kadashev exit1:
427024fb33d4SAl Viro putname(name);
42711da177e4SLinus Torvalds return error;
42721da177e4SLinus Torvalds }
42731da177e4SLinus Torvalds
SYSCALL_DEFINE1(rmdir,const char __user *,pathname)42743cdad428SHeiko Carstens SYSCALL_DEFINE1(rmdir, const char __user *, pathname)
42755590ff0dSUlrich Drepper {
4276e24ab0efSChristoph Hellwig return do_rmdir(AT_FDCWD, getname(pathname));
42775590ff0dSUlrich Drepper }
42785590ff0dSUlrich Drepper
4279b21996e3SJ. Bruce Fields /**
4280b21996e3SJ. Bruce Fields * vfs_unlink - unlink a filesystem object
4281abf08576SChristian Brauner * @idmap: idmap of the mount the inode was found from
4282b21996e3SJ. Bruce Fields * @dir: parent directory
4283b21996e3SJ. Bruce Fields * @dentry: victim
4284b21996e3SJ. Bruce Fields * @delegated_inode: returns victim inode, if the inode is delegated.
4285b21996e3SJ. Bruce Fields *
4286b21996e3SJ. Bruce Fields * The caller must hold dir->i_mutex.
4287b21996e3SJ. Bruce Fields *
4288b21996e3SJ. Bruce Fields * If vfs_unlink discovers a delegation, it will return -EWOULDBLOCK and
4289b21996e3SJ. Bruce Fields * return a reference to the inode in delegated_inode. The caller
4290b21996e3SJ. Bruce Fields * should then break the delegation on that inode and retry. Because
4291b21996e3SJ. Bruce Fields * breaking a delegation may take a long time, the caller should drop
4292b21996e3SJ. Bruce Fields * dir->i_mutex before doing so.
4293b21996e3SJ. Bruce Fields *
4294b21996e3SJ. Bruce Fields * Alternatively, a caller may pass NULL for delegated_inode. This may
4295b21996e3SJ. Bruce Fields * be appropriate for callers that expect the underlying filesystem not
4296b21996e3SJ. Bruce Fields * to be NFS exported.
42976521f891SChristian Brauner *
4298abf08576SChristian Brauner * If the inode has been found through an idmapped mount the idmap of
4299abf08576SChristian Brauner * the vfsmount must be passed through @idmap. This function will then take
4300abf08576SChristian Brauner * care to map the inode according to @idmap before checking permissions.
43016521f891SChristian Brauner * On non-idmapped mounts or if permission checking is to be performed on the
4302abf08576SChristian Brauner * raw inode simply passs @nop_mnt_idmap.
4303b21996e3SJ. Bruce Fields */
vfs_unlink(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry,struct inode ** delegated_inode)4304abf08576SChristian Brauner int vfs_unlink(struct mnt_idmap *idmap, struct inode *dir,
43056521f891SChristian Brauner struct dentry *dentry, struct inode **delegated_inode)
43061da177e4SLinus Torvalds {
43079accbb97SJ. Bruce Fields struct inode *target = dentry->d_inode;
43084609e1f1SChristian Brauner int error = may_delete(idmap, dir, dentry, 0);
43091da177e4SLinus Torvalds
43101da177e4SLinus Torvalds if (error)
43111da177e4SLinus Torvalds return error;
43121da177e4SLinus Torvalds
4313acfa4380SAl Viro if (!dir->i_op->unlink)
43141da177e4SLinus Torvalds return -EPERM;
43151da177e4SLinus Torvalds
43165955102cSAl Viro inode_lock(target);
431751cc3a66SHugh Dickins if (IS_SWAPFILE(target))
431851cc3a66SHugh Dickins error = -EPERM;
431951cc3a66SHugh Dickins else if (is_local_mountpoint(dentry))
43201da177e4SLinus Torvalds error = -EBUSY;
43211da177e4SLinus Torvalds else {
43221da177e4SLinus Torvalds error = security_inode_unlink(dir, dentry);
4323bec1052eSAl Viro if (!error) {
43245a14696cSJ. Bruce Fields error = try_break_deleg(target, delegated_inode);
43255a14696cSJ. Bruce Fields if (error)
4326b21996e3SJ. Bruce Fields goto out;
43271da177e4SLinus Torvalds error = dir->i_op->unlink(dir, dentry);
43288ed936b5SEric W. Biederman if (!error) {
4329d83c49f3SAl Viro dont_mount(dentry);
43308ed936b5SEric W. Biederman detach_mounts(dentry);
43318ed936b5SEric W. Biederman }
4332bec1052eSAl Viro }
43331da177e4SLinus Torvalds }
4334b21996e3SJ. Bruce Fields out:
43355955102cSAl Viro inode_unlock(target);
43361da177e4SLinus Torvalds
43371da177e4SLinus Torvalds /* We don't d_delete() NFS sillyrenamed files--they still exist. */
4338a37d9a17SAmir Goldstein if (!error && dentry->d_flags & DCACHE_NFSFS_RENAMED) {
4339a37d9a17SAmir Goldstein fsnotify_unlink(dir, dentry);
4340a37d9a17SAmir Goldstein } else if (!error) {
43419accbb97SJ. Bruce Fields fsnotify_link_count(target);
4342a37d9a17SAmir Goldstein d_delete_notify(dir, dentry);
43431da177e4SLinus Torvalds }
43440eeca283SRobert Love
43451da177e4SLinus Torvalds return error;
43461da177e4SLinus Torvalds }
43474d359507SAl Viro EXPORT_SYMBOL(vfs_unlink);
43481da177e4SLinus Torvalds
43491da177e4SLinus Torvalds /*
43501da177e4SLinus Torvalds * Make sure that the actual truncation of the file will occur outside its
43511b1dcc1bSJes Sorensen * directory's i_mutex. Truncate can take a long time if there is a lot of
43521da177e4SLinus Torvalds * writeout happening, and we don't want to prevent access to the directory
43531da177e4SLinus Torvalds * while waiting on the I/O.
43541da177e4SLinus Torvalds */
do_unlinkat(int dfd,struct filename * name)435545f30dabSDmitry Kadashev int do_unlinkat(int dfd, struct filename *name)
43561da177e4SLinus Torvalds {
43572ad94ae6SAl Viro int error;
43581da177e4SLinus Torvalds struct dentry *dentry;
4359f5beed75SAl Viro struct path path;
4360f5beed75SAl Viro struct qstr last;
4361f5beed75SAl Viro int type;
43621da177e4SLinus Torvalds struct inode *inode = NULL;
4363b21996e3SJ. Bruce Fields struct inode *delegated_inode = NULL;
43645d18f813SJeff Layton unsigned int lookup_flags = 0;
43655d18f813SJeff Layton retry:
4366c5f563f9SAl Viro error = filename_parentat(dfd, name, lookup_flags, &path, &last, &type);
43670ee50b47SDmitry Kadashev if (error)
43680ee50b47SDmitry Kadashev goto exit1;
43692ad94ae6SAl Viro
43701da177e4SLinus Torvalds error = -EISDIR;
4371f5beed75SAl Viro if (type != LAST_NORM)
43720ee50b47SDmitry Kadashev goto exit2;
43730612d9fbSOGAWA Hirofumi
4374f5beed75SAl Viro error = mnt_want_write(path.mnt);
4375c30dabfeSJan Kara if (error)
43760ee50b47SDmitry Kadashev goto exit2;
4377b21996e3SJ. Bruce Fields retry_deleg:
43785955102cSAl Viro inode_lock_nested(path.dentry->d_inode, I_MUTEX_PARENT);
437974d7970fSNamjae Jeon dentry = lookup_one_qstr_excl(&last, path.dentry, lookup_flags);
43801da177e4SLinus Torvalds error = PTR_ERR(dentry);
43811da177e4SLinus Torvalds if (!IS_ERR(dentry)) {
43826521f891SChristian Brauner
43831da177e4SLinus Torvalds /* Why not before? Because we want correct error value */
4384f5beed75SAl Viro if (last.name[last.len])
438550338b88STörök Edwin goto slashes;
43861da177e4SLinus Torvalds inode = dentry->d_inode;
4387b18825a7SDavid Howells if (d_is_negative(dentry))
4388e6bc45d6STheodore Ts'o goto slashes;
43897de9c6eeSAl Viro ihold(inode);
4390f5beed75SAl Viro error = security_path_unlink(&path, dentry);
4391be6d3e56SKentaro Takeda if (error)
43920ee50b47SDmitry Kadashev goto exit3;
4393abf08576SChristian Brauner error = vfs_unlink(mnt_idmap(path.mnt), path.dentry->d_inode,
4394abf08576SChristian Brauner dentry, &delegated_inode);
43950ee50b47SDmitry Kadashev exit3:
43961da177e4SLinus Torvalds dput(dentry);
43971da177e4SLinus Torvalds }
43985955102cSAl Viro inode_unlock(path.dentry->d_inode);
43991da177e4SLinus Torvalds if (inode)
44001da177e4SLinus Torvalds iput(inode); /* truncate the inode here */
4401b21996e3SJ. Bruce Fields inode = NULL;
4402b21996e3SJ. Bruce Fields if (delegated_inode) {
44035a14696cSJ. Bruce Fields error = break_deleg_wait(&delegated_inode);
4404b21996e3SJ. Bruce Fields if (!error)
4405b21996e3SJ. Bruce Fields goto retry_deleg;
4406b21996e3SJ. Bruce Fields }
4407f5beed75SAl Viro mnt_drop_write(path.mnt);
44080ee50b47SDmitry Kadashev exit2:
4409f5beed75SAl Viro path_put(&path);
44105d18f813SJeff Layton if (retry_estale(error, lookup_flags)) {
44115d18f813SJeff Layton lookup_flags |= LOOKUP_REVAL;
44125d18f813SJeff Layton inode = NULL;
44135d18f813SJeff Layton goto retry;
44145d18f813SJeff Layton }
44150ee50b47SDmitry Kadashev exit1:
4416da2f1362SChristoph Hellwig putname(name);
44171da177e4SLinus Torvalds return error;
44181da177e4SLinus Torvalds
44191da177e4SLinus Torvalds slashes:
4420b18825a7SDavid Howells if (d_is_negative(dentry))
4421b18825a7SDavid Howells error = -ENOENT;
442244b1d530SMiklos Szeredi else if (d_is_dir(dentry))
4423b18825a7SDavid Howells error = -EISDIR;
4424b18825a7SDavid Howells else
4425b18825a7SDavid Howells error = -ENOTDIR;
44260ee50b47SDmitry Kadashev goto exit3;
44271da177e4SLinus Torvalds }
44281da177e4SLinus Torvalds
SYSCALL_DEFINE3(unlinkat,int,dfd,const char __user *,pathname,int,flag)44292e4d0924SHeiko Carstens SYSCALL_DEFINE3(unlinkat, int, dfd, const char __user *, pathname, int, flag)
44305590ff0dSUlrich Drepper {
44315590ff0dSUlrich Drepper if ((flag & ~AT_REMOVEDIR) != 0)
44325590ff0dSUlrich Drepper return -EINVAL;
44335590ff0dSUlrich Drepper
44345590ff0dSUlrich Drepper if (flag & AT_REMOVEDIR)
4435e24ab0efSChristoph Hellwig return do_rmdir(dfd, getname(pathname));
4436da2f1362SChristoph Hellwig return do_unlinkat(dfd, getname(pathname));
44375590ff0dSUlrich Drepper }
44385590ff0dSUlrich Drepper
SYSCALL_DEFINE1(unlink,const char __user *,pathname)44393480b257SHeiko Carstens SYSCALL_DEFINE1(unlink, const char __user *, pathname)
44405590ff0dSUlrich Drepper {
4441da2f1362SChristoph Hellwig return do_unlinkat(AT_FDCWD, getname(pathname));
44425590ff0dSUlrich Drepper }
44435590ff0dSUlrich Drepper
44446521f891SChristian Brauner /**
44456521f891SChristian Brauner * vfs_symlink - create symlink
4446abf08576SChristian Brauner * @idmap: idmap of the mount the inode was found from
44476521f891SChristian Brauner * @dir: inode of @dentry
44486521f891SChristian Brauner * @dentry: pointer to dentry of the base directory
44496521f891SChristian Brauner * @oldname: name of the file to link to
44506521f891SChristian Brauner *
44516521f891SChristian Brauner * Create a symlink.
44526521f891SChristian Brauner *
4453abf08576SChristian Brauner * If the inode has been found through an idmapped mount the idmap of
4454abf08576SChristian Brauner * the vfsmount must be passed through @idmap. This function will then take
4455abf08576SChristian Brauner * care to map the inode according to @idmap before checking permissions.
44566521f891SChristian Brauner * On non-idmapped mounts or if permission checking is to be performed on the
4457abf08576SChristian Brauner * raw inode simply passs @nop_mnt_idmap.
44586521f891SChristian Brauner */
vfs_symlink(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry,const char * oldname)4459abf08576SChristian Brauner int vfs_symlink(struct mnt_idmap *idmap, struct inode *dir,
44606521f891SChristian Brauner struct dentry *dentry, const char *oldname)
44611da177e4SLinus Torvalds {
44627a77db95SChristian Brauner int error;
44631da177e4SLinus Torvalds
44644609e1f1SChristian Brauner error = may_create(idmap, dir, dentry);
44651da177e4SLinus Torvalds if (error)
44661da177e4SLinus Torvalds return error;
44671da177e4SLinus Torvalds
4468acfa4380SAl Viro if (!dir->i_op->symlink)
44691da177e4SLinus Torvalds return -EPERM;
44701da177e4SLinus Torvalds
44711da177e4SLinus Torvalds error = security_inode_symlink(dir, dentry, oldname);
44721da177e4SLinus Torvalds if (error)
44731da177e4SLinus Torvalds return error;
44741da177e4SLinus Torvalds
44757a77db95SChristian Brauner error = dir->i_op->symlink(idmap, dir, dentry, oldname);
4476a74574aaSStephen Smalley if (!error)
4477f38aa942SAmy Griffis fsnotify_create(dir, dentry);
44781da177e4SLinus Torvalds return error;
44791da177e4SLinus Torvalds }
44804d359507SAl Viro EXPORT_SYMBOL(vfs_symlink);
44811da177e4SLinus Torvalds
do_symlinkat(struct filename * from,int newdfd,struct filename * to)44827a8721f8SDmitry Kadashev int do_symlinkat(struct filename *from, int newdfd, struct filename *to)
44831da177e4SLinus Torvalds {
44842ad94ae6SAl Viro int error;
44856902d925SDave Hansen struct dentry *dentry;
4486dae6ad8fSAl Viro struct path path;
4487f46d3567SJeff Layton unsigned int lookup_flags = 0;
44881da177e4SLinus Torvalds
4489da2d0cedSDmitry Kadashev if (IS_ERR(from)) {
4490da2d0cedSDmitry Kadashev error = PTR_ERR(from);
4491da2d0cedSDmitry Kadashev goto out_putnames;
4492da2d0cedSDmitry Kadashev }
4493f46d3567SJeff Layton retry:
4494b4a4f213SStephen Brennan dentry = filename_create(newdfd, to, &path, lookup_flags);
44951da177e4SLinus Torvalds error = PTR_ERR(dentry);
44966902d925SDave Hansen if (IS_ERR(dentry))
4497da2d0cedSDmitry Kadashev goto out_putnames;
44986902d925SDave Hansen
449991a27b2aSJeff Layton error = security_path_symlink(&path, dentry, from->name);
4500abf08576SChristian Brauner if (!error)
4501abf08576SChristian Brauner error = vfs_symlink(mnt_idmap(path.mnt), path.dentry->d_inode,
4502abf08576SChristian Brauner dentry, from->name);
4503921a1650SAl Viro done_path_create(&path, dentry);
4504f46d3567SJeff Layton if (retry_estale(error, lookup_flags)) {
4505f46d3567SJeff Layton lookup_flags |= LOOKUP_REVAL;
4506f46d3567SJeff Layton goto retry;
4507f46d3567SJeff Layton }
4508da2d0cedSDmitry Kadashev out_putnames:
4509da2d0cedSDmitry Kadashev putname(to);
45101da177e4SLinus Torvalds putname(from);
45111da177e4SLinus Torvalds return error;
45121da177e4SLinus Torvalds }
45131da177e4SLinus Torvalds
SYSCALL_DEFINE3(symlinkat,const char __user *,oldname,int,newdfd,const char __user *,newname)4514b724e846SDominik Brodowski SYSCALL_DEFINE3(symlinkat, const char __user *, oldname,
4515b724e846SDominik Brodowski int, newdfd, const char __user *, newname)
4516b724e846SDominik Brodowski {
4517da2d0cedSDmitry Kadashev return do_symlinkat(getname(oldname), newdfd, getname(newname));
4518b724e846SDominik Brodowski }
4519b724e846SDominik Brodowski
SYSCALL_DEFINE2(symlink,const char __user *,oldname,const char __user *,newname)45203480b257SHeiko Carstens SYSCALL_DEFINE2(symlink, const char __user *, oldname, const char __user *, newname)
45215590ff0dSUlrich Drepper {
4522da2d0cedSDmitry Kadashev return do_symlinkat(getname(oldname), AT_FDCWD, getname(newname));
45235590ff0dSUlrich Drepper }
45245590ff0dSUlrich Drepper
4525146a8595SJ. Bruce Fields /**
4526146a8595SJ. Bruce Fields * vfs_link - create a new link
4527146a8595SJ. Bruce Fields * @old_dentry: object to be linked
4528abf08576SChristian Brauner * @idmap: idmap of the mount
4529146a8595SJ. Bruce Fields * @dir: new parent
4530146a8595SJ. Bruce Fields * @new_dentry: where to create the new link
4531146a8595SJ. Bruce Fields * @delegated_inode: returns inode needing a delegation break
4532146a8595SJ. Bruce Fields *
4533146a8595SJ. Bruce Fields * The caller must hold dir->i_mutex
4534146a8595SJ. Bruce Fields *
4535146a8595SJ. Bruce Fields * If vfs_link discovers a delegation on the to-be-linked file in need
4536146a8595SJ. Bruce Fields * of breaking, it will return -EWOULDBLOCK and return a reference to the
4537146a8595SJ. Bruce Fields * inode in delegated_inode. The caller should then break the delegation
4538146a8595SJ. Bruce Fields * and retry. Because breaking a delegation may take a long time, the
4539146a8595SJ. Bruce Fields * caller should drop the i_mutex before doing so.
4540146a8595SJ. Bruce Fields *
4541146a8595SJ. Bruce Fields * Alternatively, a caller may pass NULL for delegated_inode. This may
4542146a8595SJ. Bruce Fields * be appropriate for callers that expect the underlying filesystem not
4543146a8595SJ. Bruce Fields * to be NFS exported.
45446521f891SChristian Brauner *
4545abf08576SChristian Brauner * If the inode has been found through an idmapped mount the idmap of
4546abf08576SChristian Brauner * the vfsmount must be passed through @idmap. This function will then take
4547abf08576SChristian Brauner * care to map the inode according to @idmap before checking permissions.
45486521f891SChristian Brauner * On non-idmapped mounts or if permission checking is to be performed on the
4549abf08576SChristian Brauner * raw inode simply passs @nop_mnt_idmap.
4550146a8595SJ. Bruce Fields */
vfs_link(struct dentry * old_dentry,struct mnt_idmap * idmap,struct inode * dir,struct dentry * new_dentry,struct inode ** delegated_inode)4551abf08576SChristian Brauner int vfs_link(struct dentry *old_dentry, struct mnt_idmap *idmap,
45526521f891SChristian Brauner struct inode *dir, struct dentry *new_dentry,
45536521f891SChristian Brauner struct inode **delegated_inode)
45541da177e4SLinus Torvalds {
45551da177e4SLinus Torvalds struct inode *inode = old_dentry->d_inode;
45568de52778SAl Viro unsigned max_links = dir->i_sb->s_max_links;
45571da177e4SLinus Torvalds int error;
45581da177e4SLinus Torvalds
45591da177e4SLinus Torvalds if (!inode)
45601da177e4SLinus Torvalds return -ENOENT;
45611da177e4SLinus Torvalds
45624609e1f1SChristian Brauner error = may_create(idmap, dir, new_dentry);
45631da177e4SLinus Torvalds if (error)
45641da177e4SLinus Torvalds return error;
45651da177e4SLinus Torvalds
45661da177e4SLinus Torvalds if (dir->i_sb != inode->i_sb)
45671da177e4SLinus Torvalds return -EXDEV;
45681da177e4SLinus Torvalds
45691da177e4SLinus Torvalds /*
45701da177e4SLinus Torvalds * A link to an append-only or immutable file cannot be created.
45711da177e4SLinus Torvalds */
45721da177e4SLinus Torvalds if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
45731da177e4SLinus Torvalds return -EPERM;
45740bd23d09SEric W. Biederman /*
45750bd23d09SEric W. Biederman * Updating the link count will likely cause i_uid and i_gid to
45760bd23d09SEric W. Biederman * be writen back improperly if their true value is unknown to
45770bd23d09SEric W. Biederman * the vfs.
45780bd23d09SEric W. Biederman */
45794609e1f1SChristian Brauner if (HAS_UNMAPPED_ID(idmap, inode))
45800bd23d09SEric W. Biederman return -EPERM;
4581acfa4380SAl Viro if (!dir->i_op->link)
45821da177e4SLinus Torvalds return -EPERM;
45837e79eedbSTetsuo Handa if (S_ISDIR(inode->i_mode))
45841da177e4SLinus Torvalds return -EPERM;
45851da177e4SLinus Torvalds
45861da177e4SLinus Torvalds error = security_inode_link(old_dentry, dir, new_dentry);
45871da177e4SLinus Torvalds if (error)
45881da177e4SLinus Torvalds return error;
45891da177e4SLinus Torvalds
45905955102cSAl Viro inode_lock(inode);
4591aae8a97dSAneesh Kumar K.V /* Make sure we don't allow creating hardlink to an unlinked file */
4592f4e0c30cSAl Viro if (inode->i_nlink == 0 && !(inode->i_state & I_LINKABLE))
4593aae8a97dSAneesh Kumar K.V error = -ENOENT;
45948de52778SAl Viro else if (max_links && inode->i_nlink >= max_links)
45958de52778SAl Viro error = -EMLINK;
4596146a8595SJ. Bruce Fields else {
4597146a8595SJ. Bruce Fields error = try_break_deleg(inode, delegated_inode);
4598146a8595SJ. Bruce Fields if (!error)
45991da177e4SLinus Torvalds error = dir->i_op->link(old_dentry, dir, new_dentry);
4600146a8595SJ. Bruce Fields }
4601f4e0c30cSAl Viro
4602f4e0c30cSAl Viro if (!error && (inode->i_state & I_LINKABLE)) {
4603f4e0c30cSAl Viro spin_lock(&inode->i_lock);
4604f4e0c30cSAl Viro inode->i_state &= ~I_LINKABLE;
4605f4e0c30cSAl Viro spin_unlock(&inode->i_lock);
4606f4e0c30cSAl Viro }
46075955102cSAl Viro inode_unlock(inode);
4608e31e14ecSStephen Smalley if (!error)
46097e79eedbSTetsuo Handa fsnotify_link(dir, inode, new_dentry);
46101da177e4SLinus Torvalds return error;
46111da177e4SLinus Torvalds }
46124d359507SAl Viro EXPORT_SYMBOL(vfs_link);
46131da177e4SLinus Torvalds
46141da177e4SLinus Torvalds /*
46151da177e4SLinus Torvalds * Hardlinks are often used in delicate situations. We avoid
46161da177e4SLinus Torvalds * security-related surprises by not following symlinks on the
46171da177e4SLinus Torvalds * newname. --KAB
46181da177e4SLinus Torvalds *
46191da177e4SLinus Torvalds * We don't follow them on the oldname either to be compatible
46201da177e4SLinus Torvalds * with linux 2.0, and to avoid hard-linking to directories
46211da177e4SLinus Torvalds * and other special files. --ADM
46221da177e4SLinus Torvalds */
do_linkat(int olddfd,struct filename * old,int newdfd,struct filename * new,int flags)4623cf30da90SDmitry Kadashev int do_linkat(int olddfd, struct filename *old, int newdfd,
4624020250f3SDmitry Kadashev struct filename *new, int flags)
46251da177e4SLinus Torvalds {
4626abf08576SChristian Brauner struct mnt_idmap *idmap;
46271da177e4SLinus Torvalds struct dentry *new_dentry;
4628dae6ad8fSAl Viro struct path old_path, new_path;
4629146a8595SJ. Bruce Fields struct inode *delegated_inode = NULL;
463011a7b371SAneesh Kumar K.V int how = 0;
46311da177e4SLinus Torvalds int error;
46321da177e4SLinus Torvalds
4633020250f3SDmitry Kadashev if ((flags & ~(AT_SYMLINK_FOLLOW | AT_EMPTY_PATH)) != 0) {
4634020250f3SDmitry Kadashev error = -EINVAL;
4635020250f3SDmitry Kadashev goto out_putnames;
4636020250f3SDmitry Kadashev }
463711a7b371SAneesh Kumar K.V /*
4638f0cc6ffbSLinus Torvalds * To use null names we require CAP_DAC_READ_SEARCH
4639f0cc6ffbSLinus Torvalds * This ensures that not everyone will be able to create
4640f0cc6ffbSLinus Torvalds * handlink using the passed filedescriptor.
464111a7b371SAneesh Kumar K.V */
4642020250f3SDmitry Kadashev if (flags & AT_EMPTY_PATH && !capable(CAP_DAC_READ_SEARCH)) {
4643020250f3SDmitry Kadashev error = -ENOENT;
4644020250f3SDmitry Kadashev goto out_putnames;
4645f0cc6ffbSLinus Torvalds }
4646c04030e1SUlrich Drepper
464711a7b371SAneesh Kumar K.V if (flags & AT_SYMLINK_FOLLOW)
464811a7b371SAneesh Kumar K.V how |= LOOKUP_FOLLOW;
4649442e31caSJeff Layton retry:
4650794ebceaSStephen Brennan error = filename_lookup(olddfd, old, how, &old_path, NULL);
46511da177e4SLinus Torvalds if (error)
4652020250f3SDmitry Kadashev goto out_putnames;
46532ad94ae6SAl Viro
4654b4a4f213SStephen Brennan new_dentry = filename_create(newdfd, new, &new_path,
4655442e31caSJeff Layton (how & LOOKUP_REVAL));
46561da177e4SLinus Torvalds error = PTR_ERR(new_dentry);
46576902d925SDave Hansen if (IS_ERR(new_dentry))
4658020250f3SDmitry Kadashev goto out_putpath;
4659dae6ad8fSAl Viro
4660dae6ad8fSAl Viro error = -EXDEV;
4661dae6ad8fSAl Viro if (old_path.mnt != new_path.mnt)
4662dae6ad8fSAl Viro goto out_dput;
4663abf08576SChristian Brauner idmap = mnt_idmap(new_path.mnt);
46644609e1f1SChristian Brauner error = may_linkat(idmap, &old_path);
4665800179c9SKees Cook if (unlikely(error))
4666800179c9SKees Cook goto out_dput;
4667dae6ad8fSAl Viro error = security_path_link(old_path.dentry, &new_path, new_dentry);
4668be6d3e56SKentaro Takeda if (error)
4669a8104a9fSAl Viro goto out_dput;
4670abf08576SChristian Brauner error = vfs_link(old_path.dentry, idmap, new_path.dentry->d_inode,
46716521f891SChristian Brauner new_dentry, &delegated_inode);
467275c3f29dSDave Hansen out_dput:
4673921a1650SAl Viro done_path_create(&new_path, new_dentry);
4674146a8595SJ. Bruce Fields if (delegated_inode) {
4675146a8595SJ. Bruce Fields error = break_deleg_wait(&delegated_inode);
4676d22e6338SOleg Drokin if (!error) {
4677d22e6338SOleg Drokin path_put(&old_path);
4678146a8595SJ. Bruce Fields goto retry;
4679146a8595SJ. Bruce Fields }
4680d22e6338SOleg Drokin }
4681442e31caSJeff Layton if (retry_estale(error, how)) {
4682d22e6338SOleg Drokin path_put(&old_path);
4683442e31caSJeff Layton how |= LOOKUP_REVAL;
4684442e31caSJeff Layton goto retry;
4685442e31caSJeff Layton }
4686020250f3SDmitry Kadashev out_putpath:
46872d8f3038SAl Viro path_put(&old_path);
4688020250f3SDmitry Kadashev out_putnames:
4689020250f3SDmitry Kadashev putname(old);
4690020250f3SDmitry Kadashev putname(new);
46911da177e4SLinus Torvalds
46921da177e4SLinus Torvalds return error;
46931da177e4SLinus Torvalds }
46941da177e4SLinus Torvalds
SYSCALL_DEFINE5(linkat,int,olddfd,const char __user *,oldname,int,newdfd,const char __user *,newname,int,flags)469546ea89ebSDominik Brodowski SYSCALL_DEFINE5(linkat, int, olddfd, const char __user *, oldname,
469646ea89ebSDominik Brodowski int, newdfd, const char __user *, newname, int, flags)
469746ea89ebSDominik Brodowski {
4698020250f3SDmitry Kadashev return do_linkat(olddfd, getname_uflags(oldname, flags),
4699020250f3SDmitry Kadashev newdfd, getname(newname), flags);
470046ea89ebSDominik Brodowski }
470146ea89ebSDominik Brodowski
SYSCALL_DEFINE2(link,const char __user *,oldname,const char __user *,newname)47023480b257SHeiko Carstens SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newname)
47035590ff0dSUlrich Drepper {
4704020250f3SDmitry Kadashev return do_linkat(AT_FDCWD, getname(oldname), AT_FDCWD, getname(newname), 0);
47055590ff0dSUlrich Drepper }
47065590ff0dSUlrich Drepper
4707bc27027aSMiklos Szeredi /**
4708bc27027aSMiklos Szeredi * vfs_rename - rename a filesystem object
47092111c3c0SRandy Dunlap * @rd: pointer to &struct renamedata info
4710bc27027aSMiklos Szeredi *
4711bc27027aSMiklos Szeredi * The caller must hold multiple mutexes--see lock_rename()).
4712bc27027aSMiklos Szeredi *
4713bc27027aSMiklos Szeredi * If vfs_rename discovers a delegation in need of breaking at either
4714bc27027aSMiklos Szeredi * the source or destination, it will return -EWOULDBLOCK and return a
4715bc27027aSMiklos Szeredi * reference to the inode in delegated_inode. The caller should then
4716bc27027aSMiklos Szeredi * break the delegation and retry. Because breaking a delegation may
4717bc27027aSMiklos Szeredi * take a long time, the caller should drop all locks before doing
4718bc27027aSMiklos Szeredi * so.
4719bc27027aSMiklos Szeredi *
4720bc27027aSMiklos Szeredi * Alternatively, a caller may pass NULL for delegated_inode. This may
4721bc27027aSMiklos Szeredi * be appropriate for callers that expect the underlying filesystem not
4722bc27027aSMiklos Szeredi * to be NFS exported.
4723bc27027aSMiklos Szeredi *
47241da177e4SLinus Torvalds * The worst of all namespace operations - renaming directory. "Perverted"
47251da177e4SLinus Torvalds * doesn't even start to describe it. Somebody in UCB had a heck of a trip...
47261da177e4SLinus Torvalds * Problems:
47270117d427SMauro Carvalho Chehab *
4728d03b29a2SJ. Bruce Fields * a) we can get into loop creation.
47291da177e4SLinus Torvalds * b) race potential - two innocent renames can create a loop together.
4730*1db06b3dSAl Viro * That's where 4.4BSD screws up. Current fix: serialization on
4731a11f3a05SArjan van de Ven * sb->s_vfs_rename_mutex. We might be more accurate, but that's another
47321da177e4SLinus Torvalds * story.
4733*1db06b3dSAl Viro * c) we may have to lock up to _four_ objects - parents and victim (if it exists),
4734*1db06b3dSAl Viro * and source (if it's a non-directory or a subdirectory that moves to
4735*1db06b3dSAl Viro * different parent).
47361b1dcc1bSJes Sorensen * And that - after we got ->i_mutex on parents (until then we don't know
47371da177e4SLinus Torvalds * whether the target exists). Solution: try to be smart with locking
47381da177e4SLinus Torvalds * order for inodes. We rely on the fact that tree topology may change
4739a11f3a05SArjan van de Ven * only under ->s_vfs_rename_mutex _and_ that parent of the object we
47401da177e4SLinus Torvalds * move will be locked. Thus we can rank directories by the tree
47411da177e4SLinus Torvalds * (ancestors first) and rank all non-directories after them.
47421da177e4SLinus Torvalds * That works since everybody except rename does "lock parent, lookup,
4743a11f3a05SArjan van de Ven * lock child" and rename is under ->s_vfs_rename_mutex.
47441da177e4SLinus Torvalds * HOWEVER, it relies on the assumption that any object with ->lookup()
47451da177e4SLinus Torvalds * has no more than 1 dentry. If "hybrid" objects will ever appear,
47461da177e4SLinus Torvalds * we'd better make sure that there's no link(2) for them.
4747e4eaac06SSage Weil * d) conversion from fhandle to dentry may come in the wrong moment - when
47481b1dcc1bSJes Sorensen * we are removing the target. Solution: we will have to grab ->i_mutex
47491da177e4SLinus Torvalds * in the fhandle_to_dentry code. [FIXME - current nfsfh.c relies on
4750c41b20e7SAdam Buchbinder * ->i_mutex on parents, which works but leads to some truly excessive
47511da177e4SLinus Torvalds * locking].
47521da177e4SLinus Torvalds */
vfs_rename(struct renamedata * rd)47539fe61450SChristian Brauner int vfs_rename(struct renamedata *rd)
47541da177e4SLinus Torvalds {
47551da177e4SLinus Torvalds int error;
47569fe61450SChristian Brauner struct inode *old_dir = rd->old_dir, *new_dir = rd->new_dir;
47579fe61450SChristian Brauner struct dentry *old_dentry = rd->old_dentry;
47589fe61450SChristian Brauner struct dentry *new_dentry = rd->new_dentry;
47599fe61450SChristian Brauner struct inode **delegated_inode = rd->delegated_inode;
47609fe61450SChristian Brauner unsigned int flags = rd->flags;
4761bc27027aSMiklos Szeredi bool is_dir = d_is_dir(old_dentry);
4762bc27027aSMiklos Szeredi struct inode *source = old_dentry->d_inode;
4763bc27027aSMiklos Szeredi struct inode *target = new_dentry->d_inode;
4764da1ce067SMiklos Szeredi bool new_is_dir = false;
4765da1ce067SMiklos Szeredi unsigned max_links = new_dir->i_sb->s_max_links;
476649d31c2fSAl Viro struct name_snapshot old_name;
4767*1db06b3dSAl Viro bool lock_old_subdir, lock_new_subdir;
47681da177e4SLinus Torvalds
47698d3e2936SMiklos Szeredi if (source == target)
47701da177e4SLinus Torvalds return 0;
47711da177e4SLinus Torvalds
47724609e1f1SChristian Brauner error = may_delete(rd->old_mnt_idmap, old_dir, old_dentry, is_dir);
47731da177e4SLinus Torvalds if (error)
47741da177e4SLinus Torvalds return error;
47751da177e4SLinus Torvalds
4776da1ce067SMiklos Szeredi if (!target) {
47774609e1f1SChristian Brauner error = may_create(rd->new_mnt_idmap, new_dir, new_dentry);
4778da1ce067SMiklos Szeredi } else {
4779da1ce067SMiklos Szeredi new_is_dir = d_is_dir(new_dentry);
4780da1ce067SMiklos Szeredi
4781da1ce067SMiklos Szeredi if (!(flags & RENAME_EXCHANGE))
47824609e1f1SChristian Brauner error = may_delete(rd->new_mnt_idmap, new_dir,
47836521f891SChristian Brauner new_dentry, is_dir);
4784da1ce067SMiklos Szeredi else
47854609e1f1SChristian Brauner error = may_delete(rd->new_mnt_idmap, new_dir,
47866521f891SChristian Brauner new_dentry, new_is_dir);
4787da1ce067SMiklos Szeredi }
47881da177e4SLinus Torvalds if (error)
47891da177e4SLinus Torvalds return error;
47901da177e4SLinus Torvalds
47912773bf00SMiklos Szeredi if (!old_dir->i_op->rename)
47921da177e4SLinus Torvalds return -EPERM;
47931da177e4SLinus Torvalds
4794bc27027aSMiklos Szeredi /*
4795bc27027aSMiklos Szeredi * If we are going to change the parent - check write permissions,
4796bc27027aSMiklos Szeredi * we'll need to flip '..'.
4797bc27027aSMiklos Szeredi */
4798da1ce067SMiklos Szeredi if (new_dir != old_dir) {
4799da1ce067SMiklos Szeredi if (is_dir) {
48004609e1f1SChristian Brauner error = inode_permission(rd->old_mnt_idmap, source,
480147291baaSChristian Brauner MAY_WRITE);
4802bc27027aSMiklos Szeredi if (error)
4803bc27027aSMiklos Szeredi return error;
4804bc27027aSMiklos Szeredi }
4805da1ce067SMiklos Szeredi if ((flags & RENAME_EXCHANGE) && new_is_dir) {
48064609e1f1SChristian Brauner error = inode_permission(rd->new_mnt_idmap, target,
480747291baaSChristian Brauner MAY_WRITE);
4808da1ce067SMiklos Szeredi if (error)
4809da1ce067SMiklos Szeredi return error;
4810da1ce067SMiklos Szeredi }
4811da1ce067SMiklos Szeredi }
48120eeca283SRobert Love
48130b3974ebSMiklos Szeredi error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry,
48140b3974ebSMiklos Szeredi flags);
4815bc27027aSMiklos Szeredi if (error)
4816bc27027aSMiklos Szeredi return error;
4817bc27027aSMiklos Szeredi
481849d31c2fSAl Viro take_dentry_name_snapshot(&old_name, old_dentry);
4819bc27027aSMiklos Szeredi dget(new_dentry);
482028eceedaSJan Kara /*
4821*1db06b3dSAl Viro * Lock children.
4822*1db06b3dSAl Viro * The source subdirectory needs to be locked on cross-directory
4823*1db06b3dSAl Viro * rename or cross-directory exchange since its parent changes.
4824*1db06b3dSAl Viro * The target subdirectory needs to be locked on cross-directory
4825*1db06b3dSAl Viro * exchange due to parent change and on any rename due to becoming
4826*1db06b3dSAl Viro * a victim.
4827*1db06b3dSAl Viro * Non-directories need locking in all cases (for NFS reasons);
4828*1db06b3dSAl Viro * they get locked after any subdirectories (in inode address order).
4829*1db06b3dSAl Viro *
4830*1db06b3dSAl Viro * NOTE: WE ONLY LOCK UNRELATED DIRECTORIES IN CROSS-DIRECTORY CASE.
4831*1db06b3dSAl Viro * NEVER, EVER DO THAT WITHOUT ->s_vfs_rename_mutex.
483228eceedaSJan Kara */
4833*1db06b3dSAl Viro lock_old_subdir = new_dir != old_dir;
4834*1db06b3dSAl Viro lock_new_subdir = new_dir != old_dir || !(flags & RENAME_EXCHANGE);
4835*1db06b3dSAl Viro if (is_dir) {
4836*1db06b3dSAl Viro if (lock_old_subdir)
4837*1db06b3dSAl Viro inode_lock_nested(source, I_MUTEX_CHILD);
4838*1db06b3dSAl Viro if (target && (!new_is_dir || lock_new_subdir))
4839*1db06b3dSAl Viro inode_lock(target);
4840*1db06b3dSAl Viro } else if (new_is_dir) {
4841*1db06b3dSAl Viro if (lock_new_subdir)
4842*1db06b3dSAl Viro inode_lock_nested(target, I_MUTEX_CHILD);
4843*1db06b3dSAl Viro inode_lock(source);
4844*1db06b3dSAl Viro } else {
4845*1db06b3dSAl Viro lock_two_nondirectories(source, target);
4846*1db06b3dSAl Viro }
4847bc27027aSMiklos Szeredi
484851cc3a66SHugh Dickins error = -EPERM;
484951cc3a66SHugh Dickins if (IS_SWAPFILE(source) || (target && IS_SWAPFILE(target)))
485051cc3a66SHugh Dickins goto out;
485151cc3a66SHugh Dickins
4852bc27027aSMiklos Szeredi error = -EBUSY;
48537af1364fSEric W. Biederman if (is_local_mountpoint(old_dentry) || is_local_mountpoint(new_dentry))
4854bc27027aSMiklos Szeredi goto out;
4855bc27027aSMiklos Szeredi
4856da1ce067SMiklos Szeredi if (max_links && new_dir != old_dir) {
4857bc27027aSMiklos Szeredi error = -EMLINK;
4858da1ce067SMiklos Szeredi if (is_dir && !new_is_dir && new_dir->i_nlink >= max_links)
4859bc27027aSMiklos Szeredi goto out;
4860da1ce067SMiklos Szeredi if ((flags & RENAME_EXCHANGE) && !is_dir && new_is_dir &&
4861da1ce067SMiklos Szeredi old_dir->i_nlink >= max_links)
4862da1ce067SMiklos Szeredi goto out;
4863da1ce067SMiklos Szeredi }
4864da1ce067SMiklos Szeredi if (!is_dir) {
4865bc27027aSMiklos Szeredi error = try_break_deleg(source, delegated_inode);
4866bc27027aSMiklos Szeredi if (error)
4867bc27027aSMiklos Szeredi goto out;
4868da1ce067SMiklos Szeredi }
4869da1ce067SMiklos Szeredi if (target && !new_is_dir) {
4870bc27027aSMiklos Szeredi error = try_break_deleg(target, delegated_inode);
4871bc27027aSMiklos Szeredi if (error)
4872bc27027aSMiklos Szeredi goto out;
4873bc27027aSMiklos Szeredi }
4874e18275aeSChristian Brauner error = old_dir->i_op->rename(rd->new_mnt_idmap, old_dir, old_dentry,
4875520c8b16SMiklos Szeredi new_dir, new_dentry, flags);
4876bc27027aSMiklos Szeredi if (error)
4877bc27027aSMiklos Szeredi goto out;
4878bc27027aSMiklos Szeredi
4879da1ce067SMiklos Szeredi if (!(flags & RENAME_EXCHANGE) && target) {
48808767712fSAl Viro if (is_dir) {
48818767712fSAl Viro shrink_dcache_parent(new_dentry);
4882bc27027aSMiklos Szeredi target->i_flags |= S_DEAD;
48838767712fSAl Viro }
4884bc27027aSMiklos Szeredi dont_mount(new_dentry);
48858ed936b5SEric W. Biederman detach_mounts(new_dentry);
4886bc27027aSMiklos Szeredi }
4887da1ce067SMiklos Szeredi if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE)) {
4888da1ce067SMiklos Szeredi if (!(flags & RENAME_EXCHANGE))
4889bc27027aSMiklos Szeredi d_move(old_dentry, new_dentry);
4890da1ce067SMiklos Szeredi else
4891da1ce067SMiklos Szeredi d_exchange(old_dentry, new_dentry);
4892da1ce067SMiklos Szeredi }
4893bc27027aSMiklos Szeredi out:
4894*1db06b3dSAl Viro if (!is_dir || lock_old_subdir)
489528eceedaSJan Kara inode_unlock(source);
4896*1db06b3dSAl Viro if (target && (!new_is_dir || lock_new_subdir))
48975955102cSAl Viro inode_unlock(target);
4898bc27027aSMiklos Szeredi dput(new_dentry);
4899da1ce067SMiklos Szeredi if (!error) {
4900f4ec3a3dSAl Viro fsnotify_move(old_dir, new_dir, &old_name.name, is_dir,
4901da1ce067SMiklos Szeredi !(flags & RENAME_EXCHANGE) ? target : NULL, old_dentry);
4902da1ce067SMiklos Szeredi if (flags & RENAME_EXCHANGE) {
4903f4ec3a3dSAl Viro fsnotify_move(new_dir, old_dir, &old_dentry->d_name,
4904da1ce067SMiklos Szeredi new_is_dir, NULL, new_dentry);
4905da1ce067SMiklos Szeredi }
4906da1ce067SMiklos Szeredi }
490749d31c2fSAl Viro release_dentry_name_snapshot(&old_name);
49080eeca283SRobert Love
49091da177e4SLinus Torvalds return error;
49101da177e4SLinus Torvalds }
49114d359507SAl Viro EXPORT_SYMBOL(vfs_rename);
49121da177e4SLinus Torvalds
do_renameat2(int olddfd,struct filename * from,int newdfd,struct filename * to,unsigned int flags)4913e886663cSJens Axboe int do_renameat2(int olddfd, struct filename *from, int newdfd,
4914e886663cSJens Axboe struct filename *to, unsigned int flags)
49151da177e4SLinus Torvalds {
49169fe61450SChristian Brauner struct renamedata rd;
49171da177e4SLinus Torvalds struct dentry *old_dentry, *new_dentry;
49181da177e4SLinus Torvalds struct dentry *trap;
4919f5beed75SAl Viro struct path old_path, new_path;
4920f5beed75SAl Viro struct qstr old_last, new_last;
4921f5beed75SAl Viro int old_type, new_type;
49228e6d782cSJ. Bruce Fields struct inode *delegated_inode = NULL;
4923f5beed75SAl Viro unsigned int lookup_flags = 0, target_flags = LOOKUP_RENAME_TARGET;
4924c6a94284SJeff Layton bool should_retry = false;
4925e886663cSJens Axboe int error = -EINVAL;
4926520c8b16SMiklos Szeredi
49270d7a8555SMiklos Szeredi if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
49280ee50b47SDmitry Kadashev goto put_names;
4929da1ce067SMiklos Szeredi
49300d7a8555SMiklos Szeredi if ((flags & (RENAME_NOREPLACE | RENAME_WHITEOUT)) &&
49310d7a8555SMiklos Szeredi (flags & RENAME_EXCHANGE))
49320ee50b47SDmitry Kadashev goto put_names;
4933520c8b16SMiklos Szeredi
4934f5beed75SAl Viro if (flags & RENAME_EXCHANGE)
4935f5beed75SAl Viro target_flags = 0;
4936f5beed75SAl Viro
4937c6a94284SJeff Layton retry:
4938c5f563f9SAl Viro error = filename_parentat(olddfd, from, lookup_flags, &old_path,
4939e886663cSJens Axboe &old_last, &old_type);
49400ee50b47SDmitry Kadashev if (error)
49410ee50b47SDmitry Kadashev goto put_names;
49421da177e4SLinus Torvalds
4943c5f563f9SAl Viro error = filename_parentat(newdfd, to, lookup_flags, &new_path, &new_last,
4944e886663cSJens Axboe &new_type);
49450ee50b47SDmitry Kadashev if (error)
49461da177e4SLinus Torvalds goto exit1;
49471da177e4SLinus Torvalds
49481da177e4SLinus Torvalds error = -EXDEV;
4949f5beed75SAl Viro if (old_path.mnt != new_path.mnt)
49501da177e4SLinus Torvalds goto exit2;
49511da177e4SLinus Torvalds
49521da177e4SLinus Torvalds error = -EBUSY;
4953f5beed75SAl Viro if (old_type != LAST_NORM)
49541da177e4SLinus Torvalds goto exit2;
49551da177e4SLinus Torvalds
49560a7c3937SMiklos Szeredi if (flags & RENAME_NOREPLACE)
49570a7c3937SMiklos Szeredi error = -EEXIST;
4958f5beed75SAl Viro if (new_type != LAST_NORM)
49591da177e4SLinus Torvalds goto exit2;
49601da177e4SLinus Torvalds
4961f5beed75SAl Viro error = mnt_want_write(old_path.mnt);
4962c30dabfeSJan Kara if (error)
4963c30dabfeSJan Kara goto exit2;
4964c30dabfeSJan Kara
49658e6d782cSJ. Bruce Fields retry_deleg:
4966f5beed75SAl Viro trap = lock_rename(new_path.dentry, old_path.dentry);
49671da177e4SLinus Torvalds
496874d7970fSNamjae Jeon old_dentry = lookup_one_qstr_excl(&old_last, old_path.dentry,
496974d7970fSNamjae Jeon lookup_flags);
49701da177e4SLinus Torvalds error = PTR_ERR(old_dentry);
49711da177e4SLinus Torvalds if (IS_ERR(old_dentry))
49721da177e4SLinus Torvalds goto exit3;
49731da177e4SLinus Torvalds /* source must exist */
49741da177e4SLinus Torvalds error = -ENOENT;
4975b18825a7SDavid Howells if (d_is_negative(old_dentry))
49761da177e4SLinus Torvalds goto exit4;
497774d7970fSNamjae Jeon new_dentry = lookup_one_qstr_excl(&new_last, new_path.dentry,
497874d7970fSNamjae Jeon lookup_flags | target_flags);
49791da177e4SLinus Torvalds error = PTR_ERR(new_dentry);
49801da177e4SLinus Torvalds if (IS_ERR(new_dentry))
49811da177e4SLinus Torvalds goto exit4;
49820a7c3937SMiklos Szeredi error = -EEXIST;
49830a7c3937SMiklos Szeredi if ((flags & RENAME_NOREPLACE) && d_is_positive(new_dentry))
49840a7c3937SMiklos Szeredi goto exit5;
4985da1ce067SMiklos Szeredi if (flags & RENAME_EXCHANGE) {
4986da1ce067SMiklos Szeredi error = -ENOENT;
4987da1ce067SMiklos Szeredi if (d_is_negative(new_dentry))
4988da1ce067SMiklos Szeredi goto exit5;
4989da1ce067SMiklos Szeredi
4990da1ce067SMiklos Szeredi if (!d_is_dir(new_dentry)) {
4991da1ce067SMiklos Szeredi error = -ENOTDIR;
4992f5beed75SAl Viro if (new_last.name[new_last.len])
4993da1ce067SMiklos Szeredi goto exit5;
4994da1ce067SMiklos Szeredi }
4995da1ce067SMiklos Szeredi }
49960a7c3937SMiklos Szeredi /* unless the source is a directory trailing slashes give -ENOTDIR */
49970a7c3937SMiklos Szeredi if (!d_is_dir(old_dentry)) {
49980a7c3937SMiklos Szeredi error = -ENOTDIR;
4999f5beed75SAl Viro if (old_last.name[old_last.len])
50000a7c3937SMiklos Szeredi goto exit5;
5001f5beed75SAl Viro if (!(flags & RENAME_EXCHANGE) && new_last.name[new_last.len])
50020a7c3937SMiklos Szeredi goto exit5;
50030a7c3937SMiklos Szeredi }
50040a7c3937SMiklos Szeredi /* source should not be ancestor of target */
50050a7c3937SMiklos Szeredi error = -EINVAL;
50060a7c3937SMiklos Szeredi if (old_dentry == trap)
50070a7c3937SMiklos Szeredi goto exit5;
50081da177e4SLinus Torvalds /* target should not be an ancestor of source */
5009da1ce067SMiklos Szeredi if (!(flags & RENAME_EXCHANGE))
50101da177e4SLinus Torvalds error = -ENOTEMPTY;
50111da177e4SLinus Torvalds if (new_dentry == trap)
50121da177e4SLinus Torvalds goto exit5;
50131da177e4SLinus Torvalds
5014f5beed75SAl Viro error = security_path_rename(&old_path, old_dentry,
5015f5beed75SAl Viro &new_path, new_dentry, flags);
5016be6d3e56SKentaro Takeda if (error)
5017c30dabfeSJan Kara goto exit5;
50189fe61450SChristian Brauner
50199fe61450SChristian Brauner rd.old_dir = old_path.dentry->d_inode;
50209fe61450SChristian Brauner rd.old_dentry = old_dentry;
5021abf08576SChristian Brauner rd.old_mnt_idmap = mnt_idmap(old_path.mnt);
50229fe61450SChristian Brauner rd.new_dir = new_path.dentry->d_inode;
50239fe61450SChristian Brauner rd.new_dentry = new_dentry;
5024abf08576SChristian Brauner rd.new_mnt_idmap = mnt_idmap(new_path.mnt);
50259fe61450SChristian Brauner rd.delegated_inode = &delegated_inode;
50269fe61450SChristian Brauner rd.flags = flags;
50279fe61450SChristian Brauner error = vfs_rename(&rd);
50281da177e4SLinus Torvalds exit5:
50291da177e4SLinus Torvalds dput(new_dentry);
50301da177e4SLinus Torvalds exit4:
50311da177e4SLinus Torvalds dput(old_dentry);
50321da177e4SLinus Torvalds exit3:
5033f5beed75SAl Viro unlock_rename(new_path.dentry, old_path.dentry);
50348e6d782cSJ. Bruce Fields if (delegated_inode) {
50358e6d782cSJ. Bruce Fields error = break_deleg_wait(&delegated_inode);
50368e6d782cSJ. Bruce Fields if (!error)
50378e6d782cSJ. Bruce Fields goto retry_deleg;
50388e6d782cSJ. Bruce Fields }
5039f5beed75SAl Viro mnt_drop_write(old_path.mnt);
50401da177e4SLinus Torvalds exit2:
5041c6a94284SJeff Layton if (retry_estale(error, lookup_flags))
5042c6a94284SJeff Layton should_retry = true;
5043f5beed75SAl Viro path_put(&new_path);
50441da177e4SLinus Torvalds exit1:
5045f5beed75SAl Viro path_put(&old_path);
5046c6a94284SJeff Layton if (should_retry) {
5047c6a94284SJeff Layton should_retry = false;
5048c6a94284SJeff Layton lookup_flags |= LOOKUP_REVAL;
5049c6a94284SJeff Layton goto retry;
5050c6a94284SJeff Layton }
50510ee50b47SDmitry Kadashev put_names:
5052e886663cSJens Axboe putname(from);
5053e886663cSJens Axboe putname(to);
50541da177e4SLinus Torvalds return error;
50551da177e4SLinus Torvalds }
50561da177e4SLinus Torvalds
SYSCALL_DEFINE5(renameat2,int,olddfd,const char __user *,oldname,int,newdfd,const char __user *,newname,unsigned int,flags)5057ee81feb6SDominik Brodowski SYSCALL_DEFINE5(renameat2, int, olddfd, const char __user *, oldname,
5058ee81feb6SDominik Brodowski int, newdfd, const char __user *, newname, unsigned int, flags)
5059ee81feb6SDominik Brodowski {
5060e886663cSJens Axboe return do_renameat2(olddfd, getname(oldname), newdfd, getname(newname),
5061e886663cSJens Axboe flags);
5062ee81feb6SDominik Brodowski }
5063ee81feb6SDominik Brodowski
SYSCALL_DEFINE4(renameat,int,olddfd,const char __user *,oldname,int,newdfd,const char __user *,newname)5064520c8b16SMiklos Szeredi SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
5065520c8b16SMiklos Szeredi int, newdfd, const char __user *, newname)
5066520c8b16SMiklos Szeredi {
5067e886663cSJens Axboe return do_renameat2(olddfd, getname(oldname), newdfd, getname(newname),
5068e886663cSJens Axboe 0);
5069520c8b16SMiklos Szeredi }
5070520c8b16SMiklos Szeredi
SYSCALL_DEFINE2(rename,const char __user *,oldname,const char __user *,newname)5071a26eab24SHeiko Carstens SYSCALL_DEFINE2(rename, const char __user *, oldname, const char __user *, newname)
50725590ff0dSUlrich Drepper {
5073e886663cSJens Axboe return do_renameat2(AT_FDCWD, getname(oldname), AT_FDCWD,
5074e886663cSJens Axboe getname(newname), 0);
50755590ff0dSUlrich Drepper }
50765590ff0dSUlrich Drepper
readlink_copy(char __user * buffer,int buflen,const char * link)50775d826c84SAl Viro int readlink_copy(char __user *buffer, int buflen, const char *link)
50781da177e4SLinus Torvalds {
50795d826c84SAl Viro int len = PTR_ERR(link);
50801da177e4SLinus Torvalds if (IS_ERR(link))
50811da177e4SLinus Torvalds goto out;
50821da177e4SLinus Torvalds
50831da177e4SLinus Torvalds len = strlen(link);
50841da177e4SLinus Torvalds if (len > (unsigned) buflen)
50851da177e4SLinus Torvalds len = buflen;
50861da177e4SLinus Torvalds if (copy_to_user(buffer, link, len))
50871da177e4SLinus Torvalds len = -EFAULT;
50881da177e4SLinus Torvalds out:
50891da177e4SLinus Torvalds return len;
50901da177e4SLinus Torvalds }
50911da177e4SLinus Torvalds
5092d60874cdSMiklos Szeredi /**
5093fd4a0edfSMiklos Szeredi * vfs_readlink - copy symlink body into userspace buffer
5094fd4a0edfSMiklos Szeredi * @dentry: dentry on which to get symbolic link
5095fd4a0edfSMiklos Szeredi * @buffer: user memory pointer
5096fd4a0edfSMiklos Szeredi * @buflen: size of buffer
5097fd4a0edfSMiklos Szeredi *
5098fd4a0edfSMiklos Szeredi * Does not touch atime. That's up to the caller if necessary
5099fd4a0edfSMiklos Szeredi *
5100fd4a0edfSMiklos Szeredi * Does not call security hook.
5101fd4a0edfSMiklos Szeredi */
vfs_readlink(struct dentry * dentry,char __user * buffer,int buflen)5102fd4a0edfSMiklos Szeredi int vfs_readlink(struct dentry *dentry, char __user *buffer, int buflen)
5103fd4a0edfSMiklos Szeredi {
5104fd4a0edfSMiklos Szeredi struct inode *inode = d_inode(dentry);
5105f2df5da6SAl Viro DEFINE_DELAYED_CALL(done);
5106f2df5da6SAl Viro const char *link;
5107f2df5da6SAl Viro int res;
5108fd4a0edfSMiklos Szeredi
510976fca90eSMiklos Szeredi if (unlikely(!(inode->i_opflags & IOP_DEFAULT_READLINK))) {
511076fca90eSMiklos Szeredi if (unlikely(inode->i_op->readlink))
511176fca90eSMiklos Szeredi return inode->i_op->readlink(dentry, buffer, buflen);
511276fca90eSMiklos Szeredi
511376fca90eSMiklos Szeredi if (!d_is_symlink(dentry))
5114fd4a0edfSMiklos Szeredi return -EINVAL;
5115fd4a0edfSMiklos Szeredi
511676fca90eSMiklos Szeredi spin_lock(&inode->i_lock);
511776fca90eSMiklos Szeredi inode->i_opflags |= IOP_DEFAULT_READLINK;
511876fca90eSMiklos Szeredi spin_unlock(&inode->i_lock);
511976fca90eSMiklos Szeredi }
512076fca90eSMiklos Szeredi
51214c4f7c19SEric Biggers link = READ_ONCE(inode->i_link);
5122f2df5da6SAl Viro if (!link) {
5123f2df5da6SAl Viro link = inode->i_op->get_link(dentry, inode, &done);
5124f2df5da6SAl Viro if (IS_ERR(link))
5125f2df5da6SAl Viro return PTR_ERR(link);
5126f2df5da6SAl Viro }
5127f2df5da6SAl Viro res = readlink_copy(buffer, buflen, link);
5128f2df5da6SAl Viro do_delayed_call(&done);
5129f2df5da6SAl Viro return res;
5130fd4a0edfSMiklos Szeredi }
5131fd4a0edfSMiklos Szeredi EXPORT_SYMBOL(vfs_readlink);
51321da177e4SLinus Torvalds
5133d60874cdSMiklos Szeredi /**
5134d60874cdSMiklos Szeredi * vfs_get_link - get symlink body
5135d60874cdSMiklos Szeredi * @dentry: dentry on which to get symbolic link
5136d60874cdSMiklos Szeredi * @done: caller needs to free returned data with this
5137d60874cdSMiklos Szeredi *
5138d60874cdSMiklos Szeredi * Calls security hook and i_op->get_link() on the supplied inode.
5139d60874cdSMiklos Szeredi *
5140d60874cdSMiklos Szeredi * It does not touch atime. That's up to the caller if necessary.
5141d60874cdSMiklos Szeredi *
5142d60874cdSMiklos Szeredi * Does not work on "special" symlinks like /proc/$$/fd/N
5143d60874cdSMiklos Szeredi */
vfs_get_link(struct dentry * dentry,struct delayed_call * done)5144d60874cdSMiklos Szeredi const char *vfs_get_link(struct dentry *dentry, struct delayed_call *done)
5145d60874cdSMiklos Szeredi {
5146d60874cdSMiklos Szeredi const char *res = ERR_PTR(-EINVAL);
5147d60874cdSMiklos Szeredi struct inode *inode = d_inode(dentry);
5148d60874cdSMiklos Szeredi
5149d60874cdSMiklos Szeredi if (d_is_symlink(dentry)) {
5150d60874cdSMiklos Szeredi res = ERR_PTR(security_inode_readlink(dentry));
5151d60874cdSMiklos Szeredi if (!res)
5152d60874cdSMiklos Szeredi res = inode->i_op->get_link(dentry, inode, done);
5153d60874cdSMiklos Szeredi }
5154d60874cdSMiklos Szeredi return res;
5155d60874cdSMiklos Szeredi }
5156d60874cdSMiklos Szeredi EXPORT_SYMBOL(vfs_get_link);
5157d60874cdSMiklos Szeredi
51581da177e4SLinus Torvalds /* get the link contents into pagecache */
page_get_link(struct dentry * dentry,struct inode * inode,struct delayed_call * callback)51596b255391SAl Viro const char *page_get_link(struct dentry *dentry, struct inode *inode,
5160fceef393SAl Viro struct delayed_call *callback)
51611da177e4SLinus Torvalds {
5162ebd09abbSDuane Griffin char *kaddr;
51631da177e4SLinus Torvalds struct page *page;
51646b255391SAl Viro struct address_space *mapping = inode->i_mapping;
51656b255391SAl Viro
5166d3883d4fSAl Viro if (!dentry) {
5167d3883d4fSAl Viro page = find_get_page(mapping, 0);
5168d3883d4fSAl Viro if (!page)
51696b255391SAl Viro return ERR_PTR(-ECHILD);
5170d3883d4fSAl Viro if (!PageUptodate(page)) {
5171d3883d4fSAl Viro put_page(page);
5172d3883d4fSAl Viro return ERR_PTR(-ECHILD);
5173d3883d4fSAl Viro }
5174d3883d4fSAl Viro } else {
5175090d2b18SPekka Enberg page = read_mapping_page(mapping, 0, NULL);
51761da177e4SLinus Torvalds if (IS_ERR(page))
51776fe6900eSNick Piggin return (char*)page;
5178d3883d4fSAl Viro }
5179fceef393SAl Viro set_delayed_call(callback, page_put_link, page);
518021fc61c7SAl Viro BUG_ON(mapping_gfp_mask(mapping) & __GFP_HIGHMEM);
518121fc61c7SAl Viro kaddr = page_address(page);
51826b255391SAl Viro nd_terminate_link(kaddr, inode->i_size, PAGE_SIZE - 1);
5183ebd09abbSDuane Griffin return kaddr;
51841da177e4SLinus Torvalds }
51851da177e4SLinus Torvalds
51866b255391SAl Viro EXPORT_SYMBOL(page_get_link);
51871da177e4SLinus Torvalds
page_put_link(void * arg)5188fceef393SAl Viro void page_put_link(void *arg)
51891da177e4SLinus Torvalds {
5190fceef393SAl Viro put_page(arg);
51911da177e4SLinus Torvalds }
51924d359507SAl Viro EXPORT_SYMBOL(page_put_link);
51931da177e4SLinus Torvalds
page_readlink(struct dentry * dentry,char __user * buffer,int buflen)5194aa80deabSAl Viro int page_readlink(struct dentry *dentry, char __user *buffer, int buflen)
5195aa80deabSAl Viro {
5196fceef393SAl Viro DEFINE_DELAYED_CALL(done);
51976b255391SAl Viro int res = readlink_copy(buffer, buflen,
51986b255391SAl Viro page_get_link(dentry, d_inode(dentry),
5199fceef393SAl Viro &done));
5200fceef393SAl Viro do_delayed_call(&done);
5201aa80deabSAl Viro return res;
5202aa80deabSAl Viro }
5203aa80deabSAl Viro EXPORT_SYMBOL(page_readlink);
5204aa80deabSAl Viro
page_symlink(struct inode * inode,const char * symname,int len)520556f5746cSMatthew Wilcox (Oracle) int page_symlink(struct inode *inode, const char *symname, int len)
52061da177e4SLinus Torvalds {
52071da177e4SLinus Torvalds struct address_space *mapping = inode->i_mapping;
520827a77913SMatthew Wilcox (Oracle) const struct address_space_operations *aops = mapping->a_ops;
520956f5746cSMatthew Wilcox (Oracle) bool nofs = !mapping_gfp_constraint(mapping, __GFP_FS);
52100adb25d2SKirill Korotaev struct page *page;
52111468c6f4SAlexander Potapenko void *fsdata = NULL;
5212beb497abSDmitriy Monakhov int err;
52132d878178SMatthew Wilcox (Oracle) unsigned int flags;
52141da177e4SLinus Torvalds
52157e53cac4SNeilBrown retry:
52162d878178SMatthew Wilcox (Oracle) if (nofs)
52172d878178SMatthew Wilcox (Oracle) flags = memalloc_nofs_save();
521827a77913SMatthew Wilcox (Oracle) err = aops->write_begin(NULL, mapping, 0, len-1, &page, &fsdata);
52192d878178SMatthew Wilcox (Oracle) if (nofs)
52202d878178SMatthew Wilcox (Oracle) memalloc_nofs_restore(flags);
52211da177e4SLinus Torvalds if (err)
5222afddba49SNick Piggin goto fail;
5223afddba49SNick Piggin
522421fc61c7SAl Viro memcpy(page_address(page), symname, len-1);
5225afddba49SNick Piggin
522627a77913SMatthew Wilcox (Oracle) err = aops->write_end(NULL, mapping, 0, len-1, len-1,
5227afddba49SNick Piggin page, fsdata);
52281da177e4SLinus Torvalds if (err < 0)
52291da177e4SLinus Torvalds goto fail;
5230afddba49SNick Piggin if (err < len-1)
5231afddba49SNick Piggin goto retry;
5232afddba49SNick Piggin
52331da177e4SLinus Torvalds mark_inode_dirty(inode);
52341da177e4SLinus Torvalds return 0;
52351da177e4SLinus Torvalds fail:
52361da177e4SLinus Torvalds return err;
52371da177e4SLinus Torvalds }
52384d359507SAl Viro EXPORT_SYMBOL(page_symlink);
52390adb25d2SKirill Korotaev
524092e1d5beSArjan van de Ven const struct inode_operations page_symlink_inode_operations = {
52416b255391SAl Viro .get_link = page_get_link,
52421da177e4SLinus Torvalds };
52431da177e4SLinus Torvalds EXPORT_SYMBOL(page_symlink_inode_operations);
5244