1b2441318SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0 21da177e4SLinus Torvalds /* 31da177e4SLinus Torvalds * File operations used by nfsd. Some of these have been ripped from 41da177e4SLinus Torvalds * other parts of the kernel because they weren't exported, others 51da177e4SLinus Torvalds * are partial duplicates with added or changed functionality. 61da177e4SLinus Torvalds * 71da177e4SLinus Torvalds * Note that several functions dget() the dentry upon which they want 81da177e4SLinus Torvalds * to act, most notably those that create directory entries. Response 91da177e4SLinus Torvalds * dentry's are dput()'d if necessary in the release callback. 101da177e4SLinus Torvalds * So if you notice code paths that apparently fail to dput() the 111da177e4SLinus Torvalds * dentry, don't worry--they have been taken care of. 121da177e4SLinus Torvalds * 131da177e4SLinus Torvalds * Copyright (C) 1995-1999 Olaf Kirch <okir@monad.swb.de> 141da177e4SLinus Torvalds * Zerocpy NFS support (C) 2002 Hirokazu Takahashi <taka@valinux.co.jp> 151da177e4SLinus Torvalds */ 161da177e4SLinus Torvalds 171da177e4SLinus Torvalds #include <linux/fs.h> 181da177e4SLinus Torvalds #include <linux/file.h> 19d6b29d7cSJens Axboe #include <linux/splice.h> 2095d871f0SAnna Schumaker #include <linux/falloc.h> 211da177e4SLinus Torvalds #include <linux/fcntl.h> 221da177e4SLinus Torvalds #include <linux/namei.h> 231da177e4SLinus Torvalds #include <linux/delay.h> 240eeca283SRobert Love #include <linux/fsnotify.h> 251da177e4SLinus Torvalds #include <linux/posix_acl_xattr.h> 261da177e4SLinus Torvalds #include <linux/xattr.h> 279a74af21SBoaz Harrosh #include <linux/jhash.h> 289a74af21SBoaz Harrosh #include <linux/ima.h> 295a0e3ad6STejun Heo #include <linux/slab.h> 307c0f6ba6SLinus Torvalds #include <linux/uaccess.h> 31f501912aSBen Myers #include <linux/exportfs.h> 32f501912aSBen Myers #include <linux/writeback.h> 3318032ca0SDavid Quigley #include <linux/security.h> 349a74af21SBoaz Harrosh 359a74af21SBoaz Harrosh #ifdef CONFIG_NFSD_V3 369a74af21SBoaz Harrosh #include "xdr3.h" 379a74af21SBoaz Harrosh #endif /* CONFIG_NFSD_V3 */ 389a74af21SBoaz Harrosh 395be196e5SChristoph Hellwig #ifdef CONFIG_NFSD_V4 40ffa0160aSChristoph Hellwig #include "../internal.h" 412ca72e17SJ. Bruce Fields #include "acl.h" 422ca72e17SJ. Bruce Fields #include "idmap.h" 431da177e4SLinus Torvalds #endif /* CONFIG_NFSD_V4 */ 441da177e4SLinus Torvalds 459a74af21SBoaz Harrosh #include "nfsd.h" 469a74af21SBoaz Harrosh #include "vfs.h" 47b4935239SJeff Layton #include "filecache.h" 486e8b50d1SJeff Layton #include "trace.h" 491da177e4SLinus Torvalds 501da177e4SLinus Torvalds #define NFSDDBG_FACILITY NFSDDBG_FILEOP 511da177e4SLinus Torvalds 521da177e4SLinus Torvalds /* 531da177e4SLinus Torvalds * Called from nfsd_lookup and encode_dirent. Check if we have crossed 541da177e4SLinus Torvalds * a mount point. 55e0bb89efSJ.Bruce Fields * Returns -EAGAIN or -ETIMEDOUT leaving *dpp and *expp unchanged, 561da177e4SLinus Torvalds * or nfs_ok having possibly changed *dpp and *expp 571da177e4SLinus Torvalds */ 581da177e4SLinus Torvalds int 591da177e4SLinus Torvalds nfsd_cross_mnt(struct svc_rqst *rqstp, struct dentry **dpp, 601da177e4SLinus Torvalds struct svc_export **expp) 611da177e4SLinus Torvalds { 621da177e4SLinus Torvalds struct svc_export *exp = *expp, *exp2 = NULL; 631da177e4SLinus Torvalds struct dentry *dentry = *dpp; 6491c9fa8fSAl Viro struct path path = {.mnt = mntget(exp->ex_path.mnt), 6591c9fa8fSAl Viro .dentry = dget(dentry)}; 666264d69dSAl Viro int err = 0; 671da177e4SLinus Torvalds 687cc90cc3SAl Viro err = follow_down(&path); 69cc53ce53SDavid Howells if (err < 0) 70cc53ce53SDavid Howells goto out; 7199bbf6ecSNeilBrown if (path.mnt == exp->ex_path.mnt && path.dentry == dentry && 7299bbf6ecSNeilBrown nfsd_mountpoint(dentry, exp) == 2) { 7399bbf6ecSNeilBrown /* This is only a mountpoint in some other namespace */ 7499bbf6ecSNeilBrown path_put(&path); 7599bbf6ecSNeilBrown goto out; 7699bbf6ecSNeilBrown } 771da177e4SLinus Torvalds 7891c9fa8fSAl Viro exp2 = rqst_exp_get_by_name(rqstp, &path); 791da177e4SLinus Torvalds if (IS_ERR(exp2)) { 801da177e4SLinus Torvalds err = PTR_ERR(exp2); 813b6cee7bSJ. Bruce Fields /* 823b6cee7bSJ. Bruce Fields * We normally allow NFS clients to continue 833b6cee7bSJ. Bruce Fields * "underneath" a mountpoint that is not exported. 843b6cee7bSJ. Bruce Fields * The exception is V4ROOT, where no traversal is ever 853b6cee7bSJ. Bruce Fields * allowed without an explicit export of the new 863b6cee7bSJ. Bruce Fields * directory. 873b6cee7bSJ. Bruce Fields */ 883b6cee7bSJ. Bruce Fields if (err == -ENOENT && !(exp->ex_flags & NFSEXP_V4ROOT)) 893b6cee7bSJ. Bruce Fields err = 0; 9091c9fa8fSAl Viro path_put(&path); 911da177e4SLinus Torvalds goto out; 921da177e4SLinus Torvalds } 933c394ddaSSteve Dickson if (nfsd_v4client(rqstp) || 943c394ddaSSteve Dickson (exp->ex_flags & NFSEXP_CROSSMOUNT) || EX_NOHIDE(exp2)) { 951da177e4SLinus Torvalds /* successfully crossed mount point */ 961644ccc8SAl Viro /* 9791c9fa8fSAl Viro * This is subtle: path.dentry is *not* on path.mnt 9891c9fa8fSAl Viro * at this point. The only reason we are safe is that 9991c9fa8fSAl Viro * original mnt is pinned down by exp, so we should 10091c9fa8fSAl Viro * put path *before* putting exp 1011644ccc8SAl Viro */ 10291c9fa8fSAl Viro *dpp = path.dentry; 10391c9fa8fSAl Viro path.dentry = dentry; 1041644ccc8SAl Viro *expp = exp2; 10591c9fa8fSAl Viro exp2 = exp; 1061da177e4SLinus Torvalds } 10791c9fa8fSAl Viro path_put(&path); 10891c9fa8fSAl Viro exp_put(exp2); 1091da177e4SLinus Torvalds out: 1101da177e4SLinus Torvalds return err; 1111da177e4SLinus Torvalds } 1121da177e4SLinus Torvalds 113289ede45SJ. Bruce Fields static void follow_to_parent(struct path *path) 114289ede45SJ. Bruce Fields { 115289ede45SJ. Bruce Fields struct dentry *dp; 116289ede45SJ. Bruce Fields 117289ede45SJ. Bruce Fields while (path->dentry == path->mnt->mnt_root && follow_up(path)) 118289ede45SJ. Bruce Fields ; 119289ede45SJ. Bruce Fields dp = dget_parent(path->dentry); 120289ede45SJ. Bruce Fields dput(path->dentry); 121289ede45SJ. Bruce Fields path->dentry = dp; 122289ede45SJ. Bruce Fields } 123289ede45SJ. Bruce Fields 124289ede45SJ. Bruce Fields static int nfsd_lookup_parent(struct svc_rqst *rqstp, struct dentry *dparent, struct svc_export **exp, struct dentry **dentryp) 125289ede45SJ. Bruce Fields { 126289ede45SJ. Bruce Fields struct svc_export *exp2; 127289ede45SJ. Bruce Fields struct path path = {.mnt = mntget((*exp)->ex_path.mnt), 128289ede45SJ. Bruce Fields .dentry = dget(dparent)}; 129289ede45SJ. Bruce Fields 130289ede45SJ. Bruce Fields follow_to_parent(&path); 131289ede45SJ. Bruce Fields 132289ede45SJ. Bruce Fields exp2 = rqst_exp_parent(rqstp, &path); 133289ede45SJ. Bruce Fields if (PTR_ERR(exp2) == -ENOENT) { 134289ede45SJ. Bruce Fields *dentryp = dget(dparent); 135289ede45SJ. Bruce Fields } else if (IS_ERR(exp2)) { 136289ede45SJ. Bruce Fields path_put(&path); 137289ede45SJ. Bruce Fields return PTR_ERR(exp2); 138289ede45SJ. Bruce Fields } else { 139289ede45SJ. Bruce Fields *dentryp = dget(path.dentry); 140289ede45SJ. Bruce Fields exp_put(*exp); 141289ede45SJ. Bruce Fields *exp = exp2; 142289ede45SJ. Bruce Fields } 143289ede45SJ. Bruce Fields path_put(&path); 144289ede45SJ. Bruce Fields return 0; 145289ede45SJ. Bruce Fields } 146289ede45SJ. Bruce Fields 14782ead7feSJ. Bruce Fields /* 14882ead7feSJ. Bruce Fields * For nfsd purposes, we treat V4ROOT exports as though there was an 14982ead7feSJ. Bruce Fields * export at *every* directory. 15099bbf6ecSNeilBrown * We return: 15199bbf6ecSNeilBrown * '1' if this dentry *must* be an export point, 15299bbf6ecSNeilBrown * '2' if it might be, if there is really a mount here, and 15399bbf6ecSNeilBrown * '0' if there is no chance of an export point here. 15482ead7feSJ. Bruce Fields */ 1553227fa41SJ. Bruce Fields int nfsd_mountpoint(struct dentry *dentry, struct svc_export *exp) 15682ead7feSJ. Bruce Fields { 15799bbf6ecSNeilBrown if (!d_inode(dentry)) 15899bbf6ecSNeilBrown return 0; 15999bbf6ecSNeilBrown if (exp->ex_flags & NFSEXP_V4ROOT) 16082ead7feSJ. Bruce Fields return 1; 16111fcee02STrond Myklebust if (nfsd4_is_junction(dentry)) 16211fcee02STrond Myklebust return 1; 16399bbf6ecSNeilBrown if (d_mountpoint(dentry)) 16499bbf6ecSNeilBrown /* 16599bbf6ecSNeilBrown * Might only be a mountpoint in a different namespace, 16699bbf6ecSNeilBrown * but we need to check. 16799bbf6ecSNeilBrown */ 16899bbf6ecSNeilBrown return 2; 16982ead7feSJ. Bruce Fields return 0; 17082ead7feSJ. Bruce Fields } 17182ead7feSJ. Bruce Fields 1726264d69dSAl Viro __be32 1736c0a654dSJ. Bruce Fields nfsd_lookup_dentry(struct svc_rqst *rqstp, struct svc_fh *fhp, 1745a022fc8SChuck Lever const char *name, unsigned int len, 1756c0a654dSJ. Bruce Fields struct svc_export **exp_ret, struct dentry **dentry_ret) 1761da177e4SLinus Torvalds { 1771da177e4SLinus Torvalds struct svc_export *exp; 1781da177e4SLinus Torvalds struct dentry *dparent; 1791da177e4SLinus Torvalds struct dentry *dentry; 1806264d69dSAl Viro int host_err; 1811da177e4SLinus Torvalds 1821da177e4SLinus Torvalds dprintk("nfsd: nfsd_lookup(fh %s, %.*s)\n", SVCFH_fmt(fhp), len,name); 1831da177e4SLinus Torvalds 1841da177e4SLinus Torvalds dparent = fhp->fh_dentry; 185bf18f163SKinglong Mee exp = exp_get(fhp->fh_export); 1861da177e4SLinus Torvalds 1871da177e4SLinus Torvalds /* Lookup the name, but don't follow links */ 1881da177e4SLinus Torvalds if (isdotent(name, len)) { 1891da177e4SLinus Torvalds if (len==1) 1901da177e4SLinus Torvalds dentry = dget(dparent); 19154775491SJan Blunck else if (dparent != exp->ex_path.dentry) 1921da177e4SLinus Torvalds dentry = dget_parent(dparent); 193fed83811SJ. Bruce Fields else if (!EX_NOHIDE(exp) && !nfsd_v4client(rqstp)) 1941da177e4SLinus Torvalds dentry = dget(dparent); /* .. == . just like at / */ 1951da177e4SLinus Torvalds else { 1961da177e4SLinus Torvalds /* checking mountpoint crossing is very different when stepping up */ 197289ede45SJ. Bruce Fields host_err = nfsd_lookup_parent(rqstp, dparent, &exp, &dentry); 198289ede45SJ. Bruce Fields if (host_err) 1991da177e4SLinus Torvalds goto out_nfserr; 2001da177e4SLinus Torvalds } 2011da177e4SLinus Torvalds } else { 2024335723eSJ. Bruce Fields /* 2034335723eSJ. Bruce Fields * In the nfsd4_open() case, this may be held across 2044335723eSJ. Bruce Fields * subsequent open and delegation acquisition which may 2054335723eSJ. Bruce Fields * need to take the child's i_mutex: 2064335723eSJ. Bruce Fields */ 2074335723eSJ. Bruce Fields fh_lock_nested(fhp, I_MUTEX_PARENT); 2081da177e4SLinus Torvalds dentry = lookup_one_len(name, dparent, len); 2096264d69dSAl Viro host_err = PTR_ERR(dentry); 2101da177e4SLinus Torvalds if (IS_ERR(dentry)) 2111da177e4SLinus Torvalds goto out_nfserr; 21282ead7feSJ. Bruce Fields if (nfsd_mountpoint(dentry, exp)) { 213bbddca8eSNeilBrown /* 214bbddca8eSNeilBrown * We don't need the i_mutex after all. It's 215bbddca8eSNeilBrown * still possible we could open this (regular 216bbddca8eSNeilBrown * files can be mountpoints too), but the 217bbddca8eSNeilBrown * i_mutex is just there to prevent renames of 218bbddca8eSNeilBrown * something that we might be about to delegate, 219bbddca8eSNeilBrown * and a mountpoint won't be renamed: 220bbddca8eSNeilBrown */ 221bbddca8eSNeilBrown fh_unlock(fhp); 2226264d69dSAl Viro if ((host_err = nfsd_cross_mnt(rqstp, &dentry, &exp))) { 2231da177e4SLinus Torvalds dput(dentry); 2241da177e4SLinus Torvalds goto out_nfserr; 2251da177e4SLinus Torvalds } 2261da177e4SLinus Torvalds } 2271da177e4SLinus Torvalds } 2286c0a654dSJ. Bruce Fields *dentry_ret = dentry; 2296c0a654dSJ. Bruce Fields *exp_ret = exp; 2306c0a654dSJ. Bruce Fields return 0; 2316c0a654dSJ. Bruce Fields 2326c0a654dSJ. Bruce Fields out_nfserr: 2336c0a654dSJ. Bruce Fields exp_put(exp); 2346c0a654dSJ. Bruce Fields return nfserrno(host_err); 2356c0a654dSJ. Bruce Fields } 2366c0a654dSJ. Bruce Fields 2376c0a654dSJ. Bruce Fields /* 2386c0a654dSJ. Bruce Fields * Look up one component of a pathname. 2396c0a654dSJ. Bruce Fields * N.B. After this call _both_ fhp and resfh need an fh_put 2406c0a654dSJ. Bruce Fields * 2416c0a654dSJ. Bruce Fields * If the lookup would cross a mountpoint, and the mounted filesystem 2426c0a654dSJ. Bruce Fields * is exported to the client with NFSEXP_NOHIDE, then the lookup is 2436c0a654dSJ. Bruce Fields * accepted as it stands and the mounted directory is 2446c0a654dSJ. Bruce Fields * returned. Otherwise the covered directory is returned. 2456c0a654dSJ. Bruce Fields * NOTE: this mountpoint crossing is not supported properly by all 2466c0a654dSJ. Bruce Fields * clients and is explicitly disallowed for NFSv3 247ef5825e3SNeilBrown * NeilBrown <neilb@cse.unsw.edu.au> 2486c0a654dSJ. Bruce Fields */ 2496c0a654dSJ. Bruce Fields __be32 2506c0a654dSJ. Bruce Fields nfsd_lookup(struct svc_rqst *rqstp, struct svc_fh *fhp, const char *name, 2515a022fc8SChuck Lever unsigned int len, struct svc_fh *resfh) 2526c0a654dSJ. Bruce Fields { 2536c0a654dSJ. Bruce Fields struct svc_export *exp; 2546c0a654dSJ. Bruce Fields struct dentry *dentry; 2556c0a654dSJ. Bruce Fields __be32 err; 2566c0a654dSJ. Bruce Fields 25729a78a3eSJ. Bruce Fields err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_EXEC); 25829a78a3eSJ. Bruce Fields if (err) 25929a78a3eSJ. Bruce Fields return err; 2606c0a654dSJ. Bruce Fields err = nfsd_lookup_dentry(rqstp, fhp, name, len, &exp, &dentry); 2616c0a654dSJ. Bruce Fields if (err) 2626c0a654dSJ. Bruce Fields return err; 26332c1eb0cSAndy Adamson err = check_nfsd_access(exp, rqstp); 26432c1eb0cSAndy Adamson if (err) 26532c1eb0cSAndy Adamson goto out; 2661da177e4SLinus Torvalds /* 2671da177e4SLinus Torvalds * Note: we compose the file handle now, but as the 2681da177e4SLinus Torvalds * dentry may be negative, it may need to be updated. 2691da177e4SLinus Torvalds */ 2701da177e4SLinus Torvalds err = fh_compose(resfh, exp, dentry, fhp); 2712b0143b5SDavid Howells if (!err && d_really_is_negative(dentry)) 2721da177e4SLinus Torvalds err = nfserr_noent; 27332c1eb0cSAndy Adamson out: 2741da177e4SLinus Torvalds dput(dentry); 2751da177e4SLinus Torvalds exp_put(exp); 2761da177e4SLinus Torvalds return err; 2771da177e4SLinus Torvalds } 2781da177e4SLinus Torvalds 279f501912aSBen Myers /* 280f501912aSBen Myers * Commit metadata changes to stable storage. 281f501912aSBen Myers */ 282f501912aSBen Myers static int 28357f64034STrond Myklebust commit_inode_metadata(struct inode *inode) 284f501912aSBen Myers { 285f501912aSBen Myers const struct export_operations *export_ops = inode->i_sb->s_export_op; 286f501912aSBen Myers 287c3765016SChristoph Hellwig if (export_ops->commit_metadata) 288c3765016SChristoph Hellwig return export_ops->commit_metadata(inode); 289c3765016SChristoph Hellwig return sync_inode_metadata(inode, 1); 290f501912aSBen Myers } 2916c0a654dSJ. Bruce Fields 29257f64034STrond Myklebust static int 29357f64034STrond Myklebust commit_metadata(struct svc_fh *fhp) 29457f64034STrond Myklebust { 29557f64034STrond Myklebust struct inode *inode = d_inode(fhp->fh_dentry); 29657f64034STrond Myklebust 29757f64034STrond Myklebust if (!EX_ISSYNC(fhp->fh_export)) 29857f64034STrond Myklebust return 0; 29957f64034STrond Myklebust return commit_inode_metadata(inode); 30057f64034STrond Myklebust } 30157f64034STrond Myklebust 3021da177e4SLinus Torvalds /* 303818e5a22SChristoph Hellwig * Go over the attributes and take care of the small differences between 304818e5a22SChristoph Hellwig * NFS semantics and what Linux expects. 305818e5a22SChristoph Hellwig */ 306818e5a22SChristoph Hellwig static void 307818e5a22SChristoph Hellwig nfsd_sanitize_attrs(struct inode *inode, struct iattr *iap) 308818e5a22SChristoph Hellwig { 309818e5a22SChristoph Hellwig /* sanitize the mode change */ 310818e5a22SChristoph Hellwig if (iap->ia_valid & ATTR_MODE) { 311818e5a22SChristoph Hellwig iap->ia_mode &= S_IALLUGO; 312818e5a22SChristoph Hellwig iap->ia_mode |= (inode->i_mode & ~S_IALLUGO); 313818e5a22SChristoph Hellwig } 314818e5a22SChristoph Hellwig 315818e5a22SChristoph Hellwig /* Revoke setuid/setgid on chown */ 316818e5a22SChristoph Hellwig if (!S_ISDIR(inode->i_mode) && 317c4fa6d7cSStanislav Kholmanskikh ((iap->ia_valid & ATTR_UID) || (iap->ia_valid & ATTR_GID))) { 318818e5a22SChristoph Hellwig iap->ia_valid |= ATTR_KILL_PRIV; 319818e5a22SChristoph Hellwig if (iap->ia_valid & ATTR_MODE) { 320818e5a22SChristoph Hellwig /* we're setting mode too, just clear the s*id bits */ 321818e5a22SChristoph Hellwig iap->ia_mode &= ~S_ISUID; 322818e5a22SChristoph Hellwig if (iap->ia_mode & S_IXGRP) 323818e5a22SChristoph Hellwig iap->ia_mode &= ~S_ISGID; 324818e5a22SChristoph Hellwig } else { 325818e5a22SChristoph Hellwig /* set ATTR_KILL_* bits and let VFS handle it */ 326818e5a22SChristoph Hellwig iap->ia_valid |= (ATTR_KILL_SUID | ATTR_KILL_SGID); 327818e5a22SChristoph Hellwig } 328818e5a22SChristoph Hellwig } 329818e5a22SChristoph Hellwig } 330818e5a22SChristoph Hellwig 3310839ffb8SJ. Bruce Fields static __be32 3320839ffb8SJ. Bruce Fields nfsd_get_write_access(struct svc_rqst *rqstp, struct svc_fh *fhp, 3330839ffb8SJ. Bruce Fields struct iattr *iap) 3340839ffb8SJ. Bruce Fields { 3350839ffb8SJ. Bruce Fields struct inode *inode = d_inode(fhp->fh_dentry); 3360839ffb8SJ. Bruce Fields 3370839ffb8SJ. Bruce Fields if (iap->ia_size < inode->i_size) { 3380839ffb8SJ. Bruce Fields __be32 err; 3390839ffb8SJ. Bruce Fields 3400839ffb8SJ. Bruce Fields err = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry, 3410839ffb8SJ. Bruce Fields NFSD_MAY_TRUNC | NFSD_MAY_OWNER_OVERRIDE); 3420839ffb8SJ. Bruce Fields if (err) 3430839ffb8SJ. Bruce Fields return err; 3440839ffb8SJ. Bruce Fields } 345f7e33bdbSJeff Layton return nfserrno(get_write_access(inode)); 3460839ffb8SJ. Bruce Fields } 3470839ffb8SJ. Bruce Fields 348818e5a22SChristoph Hellwig /* 349818e5a22SChristoph Hellwig * Set various file attributes. After this call fhp needs an fh_put. 3501da177e4SLinus Torvalds */ 3516264d69dSAl Viro __be32 3521da177e4SLinus Torvalds nfsd_setattr(struct svc_rqst *rqstp, struct svc_fh *fhp, struct iattr *iap, 3532a1aa489SArnd Bergmann int check_guard, time64_t guardtime) 3541da177e4SLinus Torvalds { 3551da177e4SLinus Torvalds struct dentry *dentry; 3561da177e4SLinus Torvalds struct inode *inode; 3578837abcaSMiklos Szeredi int accmode = NFSD_MAY_SATTR; 358175a4eb7SAl Viro umode_t ftype = 0; 3596264d69dSAl Viro __be32 err; 3606264d69dSAl Viro int host_err; 3619f67f189SJ. Bruce Fields bool get_write_count; 362758e99feSChristoph Hellwig bool size_change = (iap->ia_valid & ATTR_SIZE); 3631da177e4SLinus Torvalds 364255fbca6Szhengbin if (iap->ia_valid & ATTR_SIZE) { 3658837abcaSMiklos Szeredi accmode |= NFSD_MAY_WRITE|NFSD_MAY_OWNER_OVERRIDE; 3661da177e4SLinus Torvalds ftype = S_IFREG; 367255fbca6Szhengbin } 368255fbca6Szhengbin 369255fbca6Szhengbin /* 370255fbca6Szhengbin * If utimes(2) and friends are called with times not NULL, we should 371255fbca6Szhengbin * not set NFSD_MAY_WRITE bit. Otherwise fh_verify->nfsd_permission 372e977cc83SGeert Uytterhoeven * will return EACCES, when the caller's effective UID does not match 373255fbca6Szhengbin * the owner of the file, and the caller is not privileged. In this 374255fbca6Szhengbin * situation, we should return EPERM(notify_change will return this). 375255fbca6Szhengbin */ 376255fbca6Szhengbin if (iap->ia_valid & (ATTR_ATIME | ATTR_MTIME)) { 377255fbca6Szhengbin accmode |= NFSD_MAY_OWNER_OVERRIDE; 378255fbca6Szhengbin if (!(iap->ia_valid & (ATTR_ATIME_SET | ATTR_MTIME_SET))) 379255fbca6Szhengbin accmode |= NFSD_MAY_WRITE; 380255fbca6Szhengbin } 3811da177e4SLinus Torvalds 3829f67f189SJ. Bruce Fields /* Callers that do fh_verify should do the fh_want_write: */ 3839f67f189SJ. Bruce Fields get_write_count = !fhp->fh_dentry; 3849f67f189SJ. Bruce Fields 3851da177e4SLinus Torvalds /* Get inode */ 3861da177e4SLinus Torvalds err = fh_verify(rqstp, fhp, ftype, accmode); 38715b7a1b8SNeilBrown if (err) 388758e99feSChristoph Hellwig return err; 3899f67f189SJ. Bruce Fields if (get_write_count) { 3909f67f189SJ. Bruce Fields host_err = fh_want_write(fhp); 3919f67f189SJ. Bruce Fields if (host_err) 392758e99feSChristoph Hellwig goto out; 3939f67f189SJ. Bruce Fields } 3941da177e4SLinus Torvalds 3951da177e4SLinus Torvalds dentry = fhp->fh_dentry; 3962b0143b5SDavid Howells inode = d_inode(dentry); 3971da177e4SLinus Torvalds 39815b7a1b8SNeilBrown /* Ignore any mode updates on symlinks */ 39915b7a1b8SNeilBrown if (S_ISLNK(inode->i_mode)) 40015b7a1b8SNeilBrown iap->ia_valid &= ~ATTR_MODE; 40115b7a1b8SNeilBrown 40215b7a1b8SNeilBrown if (!iap->ia_valid) 403758e99feSChristoph Hellwig return 0; 40415b7a1b8SNeilBrown 405818e5a22SChristoph Hellwig nfsd_sanitize_attrs(inode, iap); 4061da177e4SLinus Torvalds 407758e99feSChristoph Hellwig if (check_guard && guardtime != inode->i_ctime.tv_sec) 408758e99feSChristoph Hellwig return nfserr_notsync; 409758e99feSChristoph Hellwig 410f0c63124SChristoph Hellwig /* 41141f53350SChristoph Hellwig * The size case is special, it changes the file in addition to the 412783112f7SChristoph Hellwig * attributes, and file systems don't expect it to be mixed with 413783112f7SChristoph Hellwig * "random" attribute changes. We thus split out the size change 414783112f7SChristoph Hellwig * into a separate call to ->setattr, and do the rest as a separate 415783112f7SChristoph Hellwig * setattr call. 416f0c63124SChristoph Hellwig */ 417758e99feSChristoph Hellwig if (size_change) { 4180839ffb8SJ. Bruce Fields err = nfsd_get_write_access(rqstp, fhp, iap); 4190839ffb8SJ. Bruce Fields if (err) 420758e99feSChristoph Hellwig return err; 421783112f7SChristoph Hellwig } 42241f53350SChristoph Hellwig 423783112f7SChristoph Hellwig fh_lock(fhp); 424783112f7SChristoph Hellwig if (size_change) { 42541f53350SChristoph Hellwig /* 4260839ffb8SJ. Bruce Fields * RFC5661, Section 18.30.4: 4270839ffb8SJ. Bruce Fields * Changing the size of a file with SETATTR indirectly 4280839ffb8SJ. Bruce Fields * changes the time_modify and change attributes. 4290839ffb8SJ. Bruce Fields * 4300839ffb8SJ. Bruce Fields * (and similar for the older RFCs) 43141f53350SChristoph Hellwig */ 432783112f7SChristoph Hellwig struct iattr size_attr = { 433783112f7SChristoph Hellwig .ia_valid = ATTR_SIZE | ATTR_CTIME | ATTR_MTIME, 434783112f7SChristoph Hellwig .ia_size = iap->ia_size, 435783112f7SChristoph Hellwig }; 436783112f7SChristoph Hellwig 4372f221d6fSChristian Brauner host_err = notify_change(&init_user_ns, dentry, &size_attr, NULL); 438783112f7SChristoph Hellwig if (host_err) 439783112f7SChristoph Hellwig goto out_unlock; 440783112f7SChristoph Hellwig iap->ia_valid &= ~ATTR_SIZE; 441783112f7SChristoph Hellwig 442783112f7SChristoph Hellwig /* 443783112f7SChristoph Hellwig * Avoid the additional setattr call below if the only other 444783112f7SChristoph Hellwig * attribute that the client sends is the mtime, as we update 445783112f7SChristoph Hellwig * it as part of the size change above. 446783112f7SChristoph Hellwig */ 447783112f7SChristoph Hellwig if ((iap->ia_valid & ~ATTR_MTIME) == 0) 448783112f7SChristoph Hellwig goto out_unlock; 4491da177e4SLinus Torvalds } 4501da177e4SLinus Torvalds 4511da177e4SLinus Torvalds iap->ia_valid |= ATTR_CTIME; 4522f221d6fSChristian Brauner host_err = notify_change(&init_user_ns, dentry, iap, NULL); 453987da479SChristoph Hellwig 454783112f7SChristoph Hellwig out_unlock: 455783112f7SChristoph Hellwig fh_unlock(fhp); 4560839ffb8SJ. Bruce Fields if (size_change) 4570839ffb8SJ. Bruce Fields put_write_access(inode); 4580839ffb8SJ. Bruce Fields out: 459758e99feSChristoph Hellwig if (!host_err) 460758e99feSChristoph Hellwig host_err = commit_metadata(fhp); 461758e99feSChristoph Hellwig return nfserrno(host_err); 4621da177e4SLinus Torvalds } 4631da177e4SLinus Torvalds 4645be196e5SChristoph Hellwig #if defined(CONFIG_NFSD_V4) 4659b4146e8SChuck Lever /* 4669b4146e8SChuck Lever * NFS junction information is stored in an extended attribute. 4679b4146e8SChuck Lever */ 4689b4146e8SChuck Lever #define NFSD_JUNCTION_XATTR_NAME XATTR_TRUSTED_PREFIX "junction.nfs" 4699b4146e8SChuck Lever 4709b4146e8SChuck Lever /** 4719b4146e8SChuck Lever * nfsd4_is_junction - Test if an object could be an NFS junction 4729b4146e8SChuck Lever * 4739b4146e8SChuck Lever * @dentry: object to test 4749b4146e8SChuck Lever * 4759b4146e8SChuck Lever * Returns 1 if "dentry" appears to contain NFS junction information. 4769b4146e8SChuck Lever * Otherwise 0 is returned. 4779b4146e8SChuck Lever */ 47811fcee02STrond Myklebust int nfsd4_is_junction(struct dentry *dentry) 47911fcee02STrond Myklebust { 4802b0143b5SDavid Howells struct inode *inode = d_inode(dentry); 48111fcee02STrond Myklebust 48211fcee02STrond Myklebust if (inode == NULL) 48311fcee02STrond Myklebust return 0; 48411fcee02STrond Myklebust if (inode->i_mode & S_IXUGO) 48511fcee02STrond Myklebust return 0; 48611fcee02STrond Myklebust if (!(inode->i_mode & S_ISVTX)) 48711fcee02STrond Myklebust return 0; 488c7c7a1a1STycho Andersen if (vfs_getxattr(&init_user_ns, dentry, NFSD_JUNCTION_XATTR_NAME, 489c7c7a1a1STycho Andersen NULL, 0) <= 0) 49011fcee02STrond Myklebust return 0; 49111fcee02STrond Myklebust return 1; 49211fcee02STrond Myklebust } 49318032ca0SDavid Quigley #ifdef CONFIG_NFSD_V4_SECURITY_LABEL 49418032ca0SDavid Quigley __be32 nfsd4_set_nfs4_label(struct svc_rqst *rqstp, struct svc_fh *fhp, 49518032ca0SDavid Quigley struct xdr_netobj *label) 49618032ca0SDavid Quigley { 49718032ca0SDavid Quigley __be32 error; 49818032ca0SDavid Quigley int host_error; 49918032ca0SDavid Quigley struct dentry *dentry; 50018032ca0SDavid Quigley 50118032ca0SDavid Quigley error = fh_verify(rqstp, fhp, 0 /* S_IFREG */, NFSD_MAY_SATTR); 50218032ca0SDavid Quigley if (error) 50318032ca0SDavid Quigley return error; 50418032ca0SDavid Quigley 50518032ca0SDavid Quigley dentry = fhp->fh_dentry; 50618032ca0SDavid Quigley 5075955102cSAl Viro inode_lock(d_inode(dentry)); 50818032ca0SDavid Quigley host_error = security_inode_setsecctx(dentry, label->data, label->len); 5095955102cSAl Viro inode_unlock(d_inode(dentry)); 51018032ca0SDavid Quigley return nfserrno(host_error); 51118032ca0SDavid Quigley } 51218032ca0SDavid Quigley #else 51318032ca0SDavid Quigley __be32 nfsd4_set_nfs4_label(struct svc_rqst *rqstp, struct svc_fh *fhp, 51418032ca0SDavid Quigley struct xdr_netobj *label) 51518032ca0SDavid Quigley { 51618032ca0SDavid Quigley return nfserr_notsupp; 51718032ca0SDavid Quigley } 51818032ca0SDavid Quigley #endif 51918032ca0SDavid Quigley 520b66ae6ddSTrond Myklebust __be32 nfsd4_clone_file_range(struct nfsd_file *nf_src, u64 src_pos, 521b66ae6ddSTrond Myklebust struct nfsd_file *nf_dst, u64 dst_pos, u64 count, bool sync) 522ffa0160aSChristoph Hellwig { 523b66ae6ddSTrond Myklebust struct file *src = nf_src->nf_file; 524b66ae6ddSTrond Myklebust struct file *dst = nf_dst->nf_file; 525555dbf1aSTrond Myklebust errseq_t since; 52642ec3d4cSDarrick J. Wong loff_t cloned; 5271b28d756STrond Myklebust __be32 ret = 0; 52842ec3d4cSDarrick J. Wong 529555dbf1aSTrond Myklebust since = READ_ONCE(dst->f_wb_err); 530452ce659SDarrick J. Wong cloned = vfs_clone_file_range(src, src_pos, dst, dst_pos, count, 0); 5311b28d756STrond Myklebust if (cloned < 0) { 5321b28d756STrond Myklebust ret = nfserrno(cloned); 5331b28d756STrond Myklebust goto out_err; 5341b28d756STrond Myklebust } 5351b28d756STrond Myklebust if (count && cloned != count) { 5361b28d756STrond Myklebust ret = nfserrno(-EINVAL); 5371b28d756STrond Myklebust goto out_err; 5381b28d756STrond Myklebust } 539a25e3726STrond Myklebust if (sync) { 540a25e3726STrond Myklebust loff_t dst_end = count ? dst_pos + count - 1 : LLONG_MAX; 541a25e3726STrond Myklebust int status = vfs_fsync_range(dst, dst_pos, dst_end, 0); 54257f64034STrond Myklebust 54357f64034STrond Myklebust if (!status) 544555dbf1aSTrond Myklebust status = filemap_check_wb_err(dst->f_mapping, since); 545555dbf1aSTrond Myklebust if (!status) 54657f64034STrond Myklebust status = commit_inode_metadata(file_inode(src)); 5471b28d756STrond Myklebust if (status < 0) { 5481b28d756STrond Myklebust nfsd_reset_boot_verifier(net_generic(nf_dst->nf_net, 5491b28d756STrond Myklebust nfsd_net_id)); 5501b28d756STrond Myklebust ret = nfserrno(status); 551a25e3726STrond Myklebust } 5521b28d756STrond Myklebust } 5531b28d756STrond Myklebust out_err: 5541b28d756STrond Myklebust return ret; 555ffa0160aSChristoph Hellwig } 556ffa0160aSChristoph Hellwig 55729ae7f9dSAnna Schumaker ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst, 55829ae7f9dSAnna Schumaker u64 dst_pos, u64 count) 55929ae7f9dSAnna Schumaker { 56029ae7f9dSAnna Schumaker 56129ae7f9dSAnna Schumaker /* 56229ae7f9dSAnna Schumaker * Limit copy to 4MB to prevent indefinitely blocking an nfsd 56329ae7f9dSAnna Schumaker * thread and client rpc slot. The choice of 4MB is somewhat 56429ae7f9dSAnna Schumaker * arbitrary. We might instead base this on r/wsize, or make it 56529ae7f9dSAnna Schumaker * tunable, or use a time instead of a byte limit, or implement 56629ae7f9dSAnna Schumaker * asynchronous copy. In theory a client could also recognize a 56729ae7f9dSAnna Schumaker * limit like this and pipeline multiple COPY requests. 56829ae7f9dSAnna Schumaker */ 56929ae7f9dSAnna Schumaker count = min_t(u64, count, 1 << 22); 57029ae7f9dSAnna Schumaker return vfs_copy_file_range(src, src_pos, dst, dst_pos, count, 0); 57129ae7f9dSAnna Schumaker } 57229ae7f9dSAnna Schumaker 57395d871f0SAnna Schumaker __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp, 57495d871f0SAnna Schumaker struct file *file, loff_t offset, loff_t len, 57595d871f0SAnna Schumaker int flags) 57695d871f0SAnna Schumaker { 57795d871f0SAnna Schumaker int error; 57895d871f0SAnna Schumaker 57995d871f0SAnna Schumaker if (!S_ISREG(file_inode(file)->i_mode)) 58095d871f0SAnna Schumaker return nfserr_inval; 58195d871f0SAnna Schumaker 58295d871f0SAnna Schumaker error = vfs_fallocate(file, flags, offset, len); 58395d871f0SAnna Schumaker if (!error) 58495d871f0SAnna Schumaker error = commit_metadata(fhp); 58595d871f0SAnna Schumaker 58695d871f0SAnna Schumaker return nfserrno(error); 58795d871f0SAnna Schumaker } 5886a85d6c7SJ. Bruce Fields #endif /* defined(CONFIG_NFSD_V4) */ 5891da177e4SLinus Torvalds 5901da177e4SLinus Torvalds #ifdef CONFIG_NFSD_V3 5911da177e4SLinus Torvalds /* 5921da177e4SLinus Torvalds * Check server access rights to a file system object 5931da177e4SLinus Torvalds */ 5941da177e4SLinus Torvalds struct accessmap { 5951da177e4SLinus Torvalds u32 access; 5961da177e4SLinus Torvalds int how; 5971da177e4SLinus Torvalds }; 5981da177e4SLinus Torvalds static struct accessmap nfs3_regaccess[] = { 5998837abcaSMiklos Szeredi { NFS3_ACCESS_READ, NFSD_MAY_READ }, 6008837abcaSMiklos Szeredi { NFS3_ACCESS_EXECUTE, NFSD_MAY_EXEC }, 6018837abcaSMiklos Szeredi { NFS3_ACCESS_MODIFY, NFSD_MAY_WRITE|NFSD_MAY_TRUNC }, 6028837abcaSMiklos Szeredi { NFS3_ACCESS_EXTEND, NFSD_MAY_WRITE }, 6031da177e4SLinus Torvalds 604c11d7fd1SFrank van der Linden #ifdef CONFIG_NFSD_V4 605c11d7fd1SFrank van der Linden { NFS4_ACCESS_XAREAD, NFSD_MAY_READ }, 606c11d7fd1SFrank van der Linden { NFS4_ACCESS_XAWRITE, NFSD_MAY_WRITE }, 607c11d7fd1SFrank van der Linden { NFS4_ACCESS_XALIST, NFSD_MAY_READ }, 608c11d7fd1SFrank van der Linden #endif 609c11d7fd1SFrank van der Linden 6101da177e4SLinus Torvalds { 0, 0 } 6111da177e4SLinus Torvalds }; 6121da177e4SLinus Torvalds 6131da177e4SLinus Torvalds static struct accessmap nfs3_diraccess[] = { 6148837abcaSMiklos Szeredi { NFS3_ACCESS_READ, NFSD_MAY_READ }, 6158837abcaSMiklos Szeredi { NFS3_ACCESS_LOOKUP, NFSD_MAY_EXEC }, 6168837abcaSMiklos Szeredi { NFS3_ACCESS_MODIFY, NFSD_MAY_EXEC|NFSD_MAY_WRITE|NFSD_MAY_TRUNC}, 6178837abcaSMiklos Szeredi { NFS3_ACCESS_EXTEND, NFSD_MAY_EXEC|NFSD_MAY_WRITE }, 6188837abcaSMiklos Szeredi { NFS3_ACCESS_DELETE, NFSD_MAY_REMOVE }, 6191da177e4SLinus Torvalds 620c11d7fd1SFrank van der Linden #ifdef CONFIG_NFSD_V4 621c11d7fd1SFrank van der Linden { NFS4_ACCESS_XAREAD, NFSD_MAY_READ }, 622c11d7fd1SFrank van der Linden { NFS4_ACCESS_XAWRITE, NFSD_MAY_WRITE }, 623c11d7fd1SFrank van der Linden { NFS4_ACCESS_XALIST, NFSD_MAY_READ }, 624c11d7fd1SFrank van der Linden #endif 625c11d7fd1SFrank van der Linden 6261da177e4SLinus Torvalds { 0, 0 } 6271da177e4SLinus Torvalds }; 6281da177e4SLinus Torvalds 6291da177e4SLinus Torvalds static struct accessmap nfs3_anyaccess[] = { 6301da177e4SLinus Torvalds /* Some clients - Solaris 2.6 at least, make an access call 6311da177e4SLinus Torvalds * to the server to check for access for things like /dev/null 6321da177e4SLinus Torvalds * (which really, the server doesn't care about). So 6331da177e4SLinus Torvalds * We provide simple access checking for them, looking 6341da177e4SLinus Torvalds * mainly at mode bits, and we make sure to ignore read-only 6351da177e4SLinus Torvalds * filesystem checks 6361da177e4SLinus Torvalds */ 6378837abcaSMiklos Szeredi { NFS3_ACCESS_READ, NFSD_MAY_READ }, 6388837abcaSMiklos Szeredi { NFS3_ACCESS_EXECUTE, NFSD_MAY_EXEC }, 6398837abcaSMiklos Szeredi { NFS3_ACCESS_MODIFY, NFSD_MAY_WRITE|NFSD_MAY_LOCAL_ACCESS }, 6408837abcaSMiklos Szeredi { NFS3_ACCESS_EXTEND, NFSD_MAY_WRITE|NFSD_MAY_LOCAL_ACCESS }, 6411da177e4SLinus Torvalds 6421da177e4SLinus Torvalds { 0, 0 } 6431da177e4SLinus Torvalds }; 6441da177e4SLinus Torvalds 6456264d69dSAl Viro __be32 6461da177e4SLinus Torvalds nfsd_access(struct svc_rqst *rqstp, struct svc_fh *fhp, u32 *access, u32 *supported) 6471da177e4SLinus Torvalds { 6481da177e4SLinus Torvalds struct accessmap *map; 6491da177e4SLinus Torvalds struct svc_export *export; 6501da177e4SLinus Torvalds struct dentry *dentry; 6511da177e4SLinus Torvalds u32 query, result = 0, sresult = 0; 6526264d69dSAl Viro __be32 error; 6531da177e4SLinus Torvalds 6548837abcaSMiklos Szeredi error = fh_verify(rqstp, fhp, 0, NFSD_MAY_NOP); 6551da177e4SLinus Torvalds if (error) 6561da177e4SLinus Torvalds goto out; 6571da177e4SLinus Torvalds 6581da177e4SLinus Torvalds export = fhp->fh_export; 6591da177e4SLinus Torvalds dentry = fhp->fh_dentry; 6601da177e4SLinus Torvalds 661e36cb0b8SDavid Howells if (d_is_reg(dentry)) 6621da177e4SLinus Torvalds map = nfs3_regaccess; 663e36cb0b8SDavid Howells else if (d_is_dir(dentry)) 6641da177e4SLinus Torvalds map = nfs3_diraccess; 6651da177e4SLinus Torvalds else 6661da177e4SLinus Torvalds map = nfs3_anyaccess; 6671da177e4SLinus Torvalds 6681da177e4SLinus Torvalds 6691da177e4SLinus Torvalds query = *access; 6701da177e4SLinus Torvalds for (; map->access; map++) { 6711da177e4SLinus Torvalds if (map->access & query) { 6726264d69dSAl Viro __be32 err2; 6731da177e4SLinus Torvalds 6741da177e4SLinus Torvalds sresult |= map->access; 6751da177e4SLinus Torvalds 6760ec757dfSJ. Bruce Fields err2 = nfsd_permission(rqstp, export, dentry, map->how); 6771da177e4SLinus Torvalds switch (err2) { 6781da177e4SLinus Torvalds case nfs_ok: 6791da177e4SLinus Torvalds result |= map->access; 6801da177e4SLinus Torvalds break; 6811da177e4SLinus Torvalds 6821da177e4SLinus Torvalds /* the following error codes just mean the access was not allowed, 6831da177e4SLinus Torvalds * rather than an error occurred */ 6841da177e4SLinus Torvalds case nfserr_rofs: 6851da177e4SLinus Torvalds case nfserr_acces: 6861da177e4SLinus Torvalds case nfserr_perm: 6871da177e4SLinus Torvalds /* simply don't "or" in the access bit. */ 6881da177e4SLinus Torvalds break; 6891da177e4SLinus Torvalds default: 6901da177e4SLinus Torvalds error = err2; 6911da177e4SLinus Torvalds goto out; 6921da177e4SLinus Torvalds } 6931da177e4SLinus Torvalds } 6941da177e4SLinus Torvalds } 6951da177e4SLinus Torvalds *access = result; 6961da177e4SLinus Torvalds if (supported) 6971da177e4SLinus Torvalds *supported = sresult; 6981da177e4SLinus Torvalds 6991da177e4SLinus Torvalds out: 7001da177e4SLinus Torvalds return error; 7011da177e4SLinus Torvalds } 7021da177e4SLinus Torvalds #endif /* CONFIG_NFSD_V3 */ 7031da177e4SLinus Torvalds 70465294c1fSJeff Layton int nfsd_open_break_lease(struct inode *inode, int access) 705105f4622SJ. Bruce Fields { 706105f4622SJ. Bruce Fields unsigned int mode; 7071da177e4SLinus Torvalds 708105f4622SJ. Bruce Fields if (access & NFSD_MAY_NOT_BREAK_LEASE) 709105f4622SJ. Bruce Fields return 0; 710105f4622SJ. Bruce Fields mode = (access & NFSD_MAY_WRITE) ? O_WRONLY : O_RDONLY; 711105f4622SJ. Bruce Fields return break_lease(inode, mode | O_NONBLOCK); 712105f4622SJ. Bruce Fields } 7131da177e4SLinus Torvalds 7141da177e4SLinus Torvalds /* 7151da177e4SLinus Torvalds * Open an existing file or directory. 716999448a8SBernd Schubert * The may_flags argument indicates the type of open (read/write/lock) 717999448a8SBernd Schubert * and additional flags. 7181da177e4SLinus Torvalds * N.B. After this call fhp needs an fh_put 7191da177e4SLinus Torvalds */ 72065294c1fSJeff Layton static __be32 72165294c1fSJeff Layton __nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, umode_t type, 722999448a8SBernd Schubert int may_flags, struct file **filp) 7231da177e4SLinus Torvalds { 724765927b2SAl Viro struct path path; 7251da177e4SLinus Torvalds struct inode *inode; 7268519f994SKinglong Mee struct file *file; 7276264d69dSAl Viro int flags = O_RDONLY|O_LARGEFILE; 7286264d69dSAl Viro __be32 err; 72991885258SJeff Layton int host_err = 0; 7301da177e4SLinus Torvalds 731765927b2SAl Viro path.mnt = fhp->fh_export->ex_path.mnt; 732765927b2SAl Viro path.dentry = fhp->fh_dentry; 7332b0143b5SDavid Howells inode = d_inode(path.dentry); 7341da177e4SLinus Torvalds 7351da177e4SLinus Torvalds err = nfserr_perm; 736999448a8SBernd Schubert if (IS_APPEND(inode) && (may_flags & NFSD_MAY_WRITE)) 7371da177e4SLinus Torvalds goto out; 7381da177e4SLinus Torvalds 7391da177e4SLinus Torvalds if (!inode->i_fop) 7401da177e4SLinus Torvalds goto out; 7411da177e4SLinus Torvalds 742999448a8SBernd Schubert host_err = nfsd_open_break_lease(inode, may_flags); 7436264d69dSAl Viro if (host_err) /* NOMEM or WOULDBLOCK */ 7441da177e4SLinus Torvalds goto out_nfserr; 7451da177e4SLinus Torvalds 746999448a8SBernd Schubert if (may_flags & NFSD_MAY_WRITE) { 747999448a8SBernd Schubert if (may_flags & NFSD_MAY_READ) 7489ecb6a08SJ. Bruce Fields flags = O_RDWR|O_LARGEFILE; 7499ecb6a08SJ. Bruce Fields else 7501da177e4SLinus Torvalds flags = O_WRONLY|O_LARGEFILE; 7511da177e4SLinus Torvalds } 752999448a8SBernd Schubert 7538519f994SKinglong Mee file = dentry_open(&path, flags, current_cred()); 7548519f994SKinglong Mee if (IS_ERR(file)) { 7558519f994SKinglong Mee host_err = PTR_ERR(file); 7568519f994SKinglong Mee goto out_nfserr; 75706effdbbSBernd Schubert } 75806effdbbSBernd Schubert 7596035a27bSAl Viro host_err = ima_file_check(file, may_flags); 7608519f994SKinglong Mee if (host_err) { 761fd891454SChristoph Hellwig fput(file); 7628519f994SKinglong Mee goto out_nfserr; 7638519f994SKinglong Mee } 7648519f994SKinglong Mee 7658519f994SKinglong Mee if (may_flags & NFSD_MAY_64BIT_COOKIE) 7668519f994SKinglong Mee file->f_mode |= FMODE_64BITHASH; 7678519f994SKinglong Mee else 7688519f994SKinglong Mee file->f_mode |= FMODE_32BITHASH; 7698519f994SKinglong Mee 7708519f994SKinglong Mee *filp = file; 7711da177e4SLinus Torvalds out_nfserr: 7726264d69dSAl Viro err = nfserrno(host_err); 7731da177e4SLinus Torvalds out: 77465294c1fSJeff Layton return err; 77565294c1fSJeff Layton } 77665294c1fSJeff Layton 77765294c1fSJeff Layton __be32 77865294c1fSJeff Layton nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, umode_t type, 77965294c1fSJeff Layton int may_flags, struct file **filp) 78065294c1fSJeff Layton { 78165294c1fSJeff Layton __be32 err; 78212bcbd40SJeff Layton bool retried = false; 78365294c1fSJeff Layton 78465294c1fSJeff Layton validate_process_creds(); 78565294c1fSJeff Layton /* 78665294c1fSJeff Layton * If we get here, then the client has already done an "open", 78765294c1fSJeff Layton * and (hopefully) checked permission - so allow OWNER_OVERRIDE 78865294c1fSJeff Layton * in case a chmod has now revoked permission. 78965294c1fSJeff Layton * 79065294c1fSJeff Layton * Arguably we should also allow the owner override for 79165294c1fSJeff Layton * directories, but we never have and it doesn't seem to have 79265294c1fSJeff Layton * caused anyone a problem. If we were to change this, note 79365294c1fSJeff Layton * also that our filldir callbacks would need a variant of 79465294c1fSJeff Layton * lookup_one_len that doesn't check permissions. 79565294c1fSJeff Layton */ 79665294c1fSJeff Layton if (type == S_IFREG) 79765294c1fSJeff Layton may_flags |= NFSD_MAY_OWNER_OVERRIDE; 79812bcbd40SJeff Layton retry: 79965294c1fSJeff Layton err = fh_verify(rqstp, fhp, type, may_flags); 80012bcbd40SJeff Layton if (!err) { 80165294c1fSJeff Layton err = __nfsd_open(rqstp, fhp, type, may_flags, filp); 80212bcbd40SJeff Layton if (err == nfserr_stale && !retried) { 80312bcbd40SJeff Layton retried = true; 80412bcbd40SJeff Layton fh_put(fhp); 80512bcbd40SJeff Layton goto retry; 80612bcbd40SJeff Layton } 80712bcbd40SJeff Layton } 808e0e81739SDavid Howells validate_process_creds(); 8091da177e4SLinus Torvalds return err; 8101da177e4SLinus Torvalds } 8111da177e4SLinus Torvalds 81265294c1fSJeff Layton __be32 81365294c1fSJeff Layton nfsd_open_verified(struct svc_rqst *rqstp, struct svc_fh *fhp, umode_t type, 81465294c1fSJeff Layton int may_flags, struct file **filp) 81565294c1fSJeff Layton { 81665294c1fSJeff Layton __be32 err; 81765294c1fSJeff Layton 81865294c1fSJeff Layton validate_process_creds(); 81965294c1fSJeff Layton err = __nfsd_open(rqstp, fhp, type, may_flags, filp); 82065294c1fSJeff Layton validate_process_creds(); 82165294c1fSJeff Layton return err; 82265294c1fSJeff Layton } 82365294c1fSJeff Layton 8241da177e4SLinus Torvalds /* 825cf8208d0SJens Axboe * Grab and keep cached pages associated with a file in the svc_rqst 826cf8208d0SJens Axboe * so that they can be passed to the network sendmsg/sendpage routines 827cf8208d0SJens Axboe * directly. They will be released after the sending has completed. 8281da177e4SLinus Torvalds */ 8291da177e4SLinus Torvalds static int 830cf8208d0SJens Axboe nfsd_splice_actor(struct pipe_inode_info *pipe, struct pipe_buffer *buf, 831cf8208d0SJens Axboe struct splice_desc *sd) 8321da177e4SLinus Torvalds { 833cf8208d0SJens Axboe struct svc_rqst *rqstp = sd->u.data; 834afc59400SJ. Bruce Fields struct page **pp = rqstp->rq_next_page; 835cf8208d0SJens Axboe struct page *page = buf->page; 8361da177e4SLinus Torvalds 8371da177e4SLinus Torvalds if (rqstp->rq_res.page_len == 0) { 838496d83cfSChuck Lever svc_rqst_replace_page(rqstp, page); 839cf8208d0SJens Axboe rqstp->rq_res.page_base = buf->offset; 84044524359SNeilBrown } else if (page != pp[-1]) { 841496d83cfSChuck Lever svc_rqst_replace_page(rqstp, page); 842c7e0b781SChuck Lever } 843c7e0b781SChuck Lever rqstp->rq_res.page_len += sd->len; 8441da177e4SLinus Torvalds 845c7e0b781SChuck Lever return sd->len; 8461da177e4SLinus Torvalds } 8471da177e4SLinus Torvalds 848cf8208d0SJens Axboe static int nfsd_direct_splice_actor(struct pipe_inode_info *pipe, 849cf8208d0SJens Axboe struct splice_desc *sd) 850cf8208d0SJens Axboe { 851cf8208d0SJens Axboe return __splice_from_pipe(pipe, sd, nfsd_splice_actor); 852cf8208d0SJens Axboe } 853cf8208d0SJens Axboe 85483a63072STrond Myklebust static u32 nfsd_eof_on_read(struct file *file, loff_t offset, ssize_t len, 85583a63072STrond Myklebust size_t expected) 85683a63072STrond Myklebust { 85783a63072STrond Myklebust if (expected != 0 && len == 0) 85883a63072STrond Myklebust return 1; 85983a63072STrond Myklebust if (offset+len >= i_size_read(file_inode(file))) 86083a63072STrond Myklebust return 1; 86183a63072STrond Myklebust return 0; 86283a63072STrond Myklebust } 86383a63072STrond Myklebust 86487c5942eSChuck Lever static __be32 nfsd_finish_read(struct svc_rqst *rqstp, struct svc_fh *fhp, 86587c5942eSChuck Lever struct file *file, loff_t offset, 86683a63072STrond Myklebust unsigned long *count, u32 *eof, ssize_t host_err) 8671da177e4SLinus Torvalds { 868dc97618dSJ. Bruce Fields if (host_err >= 0) { 86920ad856eSAmir Goldstein nfsd_stats_io_read_add(fhp->fh_export, host_err); 87083a63072STrond Myklebust *eof = nfsd_eof_on_read(file, offset, host_err, *count); 871dc97618dSJ. Bruce Fields *count = host_err; 872dc97618dSJ. Bruce Fields fsnotify_access(file); 87387c5942eSChuck Lever trace_nfsd_read_io_done(rqstp, fhp, offset, *count); 874dc97618dSJ. Bruce Fields return 0; 87587c5942eSChuck Lever } else { 87687c5942eSChuck Lever trace_nfsd_read_err(rqstp, fhp, offset, host_err); 877dc97618dSJ. Bruce Fields return nfserrno(host_err); 878dc97618dSJ. Bruce Fields } 87987c5942eSChuck Lever } 8801da177e4SLinus Torvalds 88187c5942eSChuck Lever __be32 nfsd_splice_read(struct svc_rqst *rqstp, struct svc_fh *fhp, 88283a63072STrond Myklebust struct file *file, loff_t offset, unsigned long *count, 88383a63072STrond Myklebust u32 *eof) 884dc97618dSJ. Bruce Fields { 885cf8208d0SJens Axboe struct splice_desc sd = { 886cf8208d0SJens Axboe .len = 0, 887cf8208d0SJens Axboe .total_len = *count, 888cf8208d0SJens Axboe .pos = offset, 889cf8208d0SJens Axboe .u.data = rqstp, 890cf8208d0SJens Axboe }; 89183a63072STrond Myklebust ssize_t host_err; 892cf8208d0SJens Axboe 89387c5942eSChuck Lever trace_nfsd_read_splice(rqstp, fhp, offset, *count); 894afc59400SJ. Bruce Fields rqstp->rq_next_page = rqstp->rq_respages + 1; 895cf8208d0SJens Axboe host_err = splice_direct_to_actor(file, &sd, nfsd_direct_splice_actor); 89683a63072STrond Myklebust return nfsd_finish_read(rqstp, fhp, file, offset, count, eof, host_err); 897dc97618dSJ. Bruce Fields } 898dc97618dSJ. Bruce Fields 89987c5942eSChuck Lever __be32 nfsd_readv(struct svc_rqst *rqstp, struct svc_fh *fhp, 90087c5942eSChuck Lever struct file *file, loff_t offset, 90183a63072STrond Myklebust struct kvec *vec, int vlen, unsigned long *count, 90283a63072STrond Myklebust u32 *eof) 903dc97618dSJ. Bruce Fields { 90473da852eSChristoph Hellwig struct iov_iter iter; 90583a63072STrond Myklebust loff_t ppos = offset; 90683a63072STrond Myklebust ssize_t host_err; 907dc97618dSJ. Bruce Fields 90887c5942eSChuck Lever trace_nfsd_read_vector(rqstp, fhp, offset, *count); 909aa563d7bSDavid Howells iov_iter_kvec(&iter, READ, vec, vlen, *count); 91083a63072STrond Myklebust host_err = vfs_iter_read(file, &iter, &ppos, 0); 91183a63072STrond Myklebust return nfsd_finish_read(rqstp, fhp, file, offset, count, eof, host_err); 9121da177e4SLinus Torvalds } 9131da177e4SLinus Torvalds 914d911df7bSJ. Bruce Fields /* 915d911df7bSJ. Bruce Fields * Gathered writes: If another process is currently writing to the file, 916d911df7bSJ. Bruce Fields * there's a high chance this is another nfsd (triggered by a bulk write 917d911df7bSJ. Bruce Fields * from a client's biod). Rather than syncing the file with each write 918d911df7bSJ. Bruce Fields * request, we sleep for 10 msec. 919d911df7bSJ. Bruce Fields * 920d911df7bSJ. Bruce Fields * I don't know if this roughly approximates C. Juszak's idea of 921d911df7bSJ. Bruce Fields * gathered writes, but it's a nice and simple solution (IMHO), and it 922d911df7bSJ. Bruce Fields * seems to work:-) 923d911df7bSJ. Bruce Fields * 924d911df7bSJ. Bruce Fields * Note: we do this only in the NFSv2 case, since v3 and higher have a 925d911df7bSJ. Bruce Fields * better tool (separate unstable writes and commits) for solving this 926d911df7bSJ. Bruce Fields * problem. 927d911df7bSJ. Bruce Fields */ 928d911df7bSJ. Bruce Fields static int wait_for_concurrent_writes(struct file *file) 929d911df7bSJ. Bruce Fields { 930496ad9aaSAl Viro struct inode *inode = file_inode(file); 931d911df7bSJ. Bruce Fields static ino_t last_ino; 932d911df7bSJ. Bruce Fields static dev_t last_dev; 933d911df7bSJ. Bruce Fields int err = 0; 934d911df7bSJ. Bruce Fields 935d911df7bSJ. Bruce Fields if (atomic_read(&inode->i_writecount) > 1 936d911df7bSJ. Bruce Fields || (last_ino == inode->i_ino && last_dev == inode->i_sb->s_dev)) { 937d911df7bSJ. Bruce Fields dprintk("nfsd: write defer %d\n", task_pid_nr(current)); 938d911df7bSJ. Bruce Fields msleep(10); 939d911df7bSJ. Bruce Fields dprintk("nfsd: write resume %d\n", task_pid_nr(current)); 940d911df7bSJ. Bruce Fields } 941d911df7bSJ. Bruce Fields 942d911df7bSJ. Bruce Fields if (inode->i_state & I_DIRTY) { 943d911df7bSJ. Bruce Fields dprintk("nfsd: write sync %d\n", task_pid_nr(current)); 9448018ab05SChristoph Hellwig err = vfs_fsync(file, 0); 945d911df7bSJ. Bruce Fields } 946d911df7bSJ. Bruce Fields last_ino = inode->i_ino; 947d911df7bSJ. Bruce Fields last_dev = inode->i_sb->s_dev; 948d911df7bSJ. Bruce Fields return err; 949d911df7bSJ. Bruce Fields } 950d911df7bSJ. Bruce Fields 951af90f707SChristoph Hellwig __be32 95216f8f894STrond Myklebust nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct nfsd_file *nf, 9531da177e4SLinus Torvalds loff_t offset, struct kvec *vec, int vlen, 95419e0663fSTrond Myklebust unsigned long *cnt, int stable, 95519e0663fSTrond Myklebust __be32 *verf) 9561da177e4SLinus Torvalds { 957fb7622c2SChuck Lever struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 95816f8f894STrond Myklebust struct file *file = nf->nf_file; 95901cbf385STrond Myklebust struct super_block *sb = file_inode(file)->i_sb; 9601da177e4SLinus Torvalds struct svc_export *exp; 96173da852eSChristoph Hellwig struct iov_iter iter; 962555dbf1aSTrond Myklebust errseq_t since; 963d890be15SChuck Lever __be32 nfserr; 9646264d69dSAl Viro int host_err; 96548e03bc5STrond Myklebust int use_wgather; 966e49dbbf3SKent Overstreet loff_t pos = offset; 96701cbf385STrond Myklebust unsigned long exp_op_flags = 0; 9688658452eSNeilBrown unsigned int pflags = current->flags; 969ddef7ed2SChristoph Hellwig rwf_t flags = 0; 97001cbf385STrond Myklebust bool restore_flags = false; 9718658452eSNeilBrown 972d890be15SChuck Lever trace_nfsd_write_opened(rqstp, fhp, offset, *cnt); 973d890be15SChuck Lever 97401cbf385STrond Myklebust if (sb->s_export_op) 97501cbf385STrond Myklebust exp_op_flags = sb->s_export_op->flags; 97601cbf385STrond Myklebust 97701cbf385STrond Myklebust if (test_bit(RQ_LOCAL, &rqstp->rq_flags) && 97801cbf385STrond Myklebust !(exp_op_flags & EXPORT_OP_REMOTE_FS)) { 9798658452eSNeilBrown /* 980a37b0715SNeilBrown * We want throttling in balance_dirty_pages() 981a37b0715SNeilBrown * and shrink_inactive_list() to only consider 982a37b0715SNeilBrown * the backingdev we are writing to, so that nfs to 9838658452eSNeilBrown * localhost doesn't cause nfsd to lock up due to all 9848658452eSNeilBrown * the client's dirty pages or its congested queue. 9858658452eSNeilBrown */ 986a37b0715SNeilBrown current->flags |= PF_LOCAL_THROTTLE; 98701cbf385STrond Myklebust restore_flags = true; 98801cbf385STrond Myklebust } 9891da177e4SLinus Torvalds 9901da177e4SLinus Torvalds exp = fhp->fh_export; 99148e03bc5STrond Myklebust use_wgather = (rqstp->rq_vers == 2) && EX_WGATHER(exp); 9921da177e4SLinus Torvalds 9931da177e4SLinus Torvalds if (!EX_ISSYNC(exp)) 99454bbb7d2SKinglong Mee stable = NFS_UNSTABLE; 9951da177e4SLinus Torvalds 99624368aadSChristoph Hellwig if (stable && !use_wgather) 99724368aadSChristoph Hellwig flags |= RWF_SYNC; 99824368aadSChristoph Hellwig 999aa563d7bSDavid Howells iov_iter_kvec(&iter, WRITE, vec, vlen, *cnt); 1000555dbf1aSTrond Myklebust since = READ_ONCE(file->f_wb_err); 1001f11ad7aaSChuck Lever if (verf) 1002fb7622c2SChuck Lever nfsd_copy_boot_verifier(verf, nn); 100373da852eSChristoph Hellwig host_err = vfs_iter_write(file, &iter, &pos, flags); 10047bf94c6bSTrond Myklebust if (host_err < 0) { 1005fb7622c2SChuck Lever nfsd_reset_boot_verifier(nn); 1006e4636d53SJ. Bruce Fields goto out_nfserr; 10077bf94c6bSTrond Myklebust } 100809a80f2aSTrond Myklebust *cnt = host_err; 100920ad856eSAmir Goldstein nfsd_stats_io_write_add(exp, *cnt); 10102a12a9d7SEric Paris fsnotify_modify(file); 1011555dbf1aSTrond Myklebust host_err = filemap_check_wb_err(file->f_mapping, since); 1012555dbf1aSTrond Myklebust if (host_err < 0) 1013555dbf1aSTrond Myklebust goto out_nfserr; 10141da177e4SLinus Torvalds 1015bbf2f098STrond Myklebust if (stable && use_wgather) { 1016d911df7bSJ. Bruce Fields host_err = wait_for_concurrent_writes(file); 1017bbf2f098STrond Myklebust if (host_err < 0) 1018fb7622c2SChuck Lever nfsd_reset_boot_verifier(nn); 1019bbf2f098STrond Myklebust } 10201da177e4SLinus Torvalds 1021e4636d53SJ. Bruce Fields out_nfserr: 1022d890be15SChuck Lever if (host_err >= 0) { 1023d890be15SChuck Lever trace_nfsd_write_io_done(rqstp, fhp, offset, *cnt); 1024d890be15SChuck Lever nfserr = nfs_ok; 1025d890be15SChuck Lever } else { 1026d890be15SChuck Lever trace_nfsd_write_err(rqstp, fhp, offset, host_err); 1027d890be15SChuck Lever nfserr = nfserrno(host_err); 1028d890be15SChuck Lever } 102901cbf385STrond Myklebust if (restore_flags) 1030a37b0715SNeilBrown current_restore_flags(pflags, PF_LOCAL_THROTTLE); 1031d890be15SChuck Lever return nfserr; 10321da177e4SLinus Torvalds } 10331da177e4SLinus Torvalds 1034dc97618dSJ. Bruce Fields /* 1035dc97618dSJ. Bruce Fields * Read data from a file. count must contain the requested read count 1036dc97618dSJ. Bruce Fields * on entry. On return, *count contains the number of bytes actually read. 1037dc97618dSJ. Bruce Fields * N.B. After this call fhp needs an fh_put 1038dc97618dSJ. Bruce Fields */ 1039dc97618dSJ. Bruce Fields __be32 nfsd_read(struct svc_rqst *rqstp, struct svc_fh *fhp, 104083a63072STrond Myklebust loff_t offset, struct kvec *vec, int vlen, unsigned long *count, 104183a63072STrond Myklebust u32 *eof) 1042dc97618dSJ. Bruce Fields { 104348cd7b51SJeff Layton struct nfsd_file *nf; 1044dc97618dSJ. Bruce Fields struct file *file; 1045dc97618dSJ. Bruce Fields __be32 err; 1046dc97618dSJ. Bruce Fields 1047f394b62bSChuck Lever trace_nfsd_read_start(rqstp, fhp, offset, *count); 104848cd7b51SJeff Layton err = nfsd_file_acquire(rqstp, fhp, NFSD_MAY_READ, &nf); 1049dc97618dSJ. Bruce Fields if (err) 1050dc97618dSJ. Bruce Fields return err; 1051dc97618dSJ. Bruce Fields 105248cd7b51SJeff Layton file = nf->nf_file; 1053a4058c5bSChristoph Hellwig if (file->f_op->splice_read && test_bit(RQ_SPLICE_OK, &rqstp->rq_flags)) 105483a63072STrond Myklebust err = nfsd_splice_read(rqstp, fhp, file, offset, count, eof); 1055a4058c5bSChristoph Hellwig else 105683a63072STrond Myklebust err = nfsd_readv(rqstp, fhp, file, offset, vec, vlen, count, eof); 10576e8b50d1SJeff Layton 105848cd7b51SJeff Layton nfsd_file_put(nf); 1059dc97618dSJ. Bruce Fields 1060f394b62bSChuck Lever trace_nfsd_read_done(rqstp, fhp, offset, *count); 10616e8b50d1SJeff Layton 1062fa0a2126SJ. Bruce Fields return err; 1063fa0a2126SJ. Bruce Fields } 1064fa0a2126SJ. Bruce Fields 10651da177e4SLinus Torvalds /* 10661da177e4SLinus Torvalds * Write data to a file. 10671da177e4SLinus Torvalds * The stable flag requests synchronous writes. 10681da177e4SLinus Torvalds * N.B. After this call fhp needs an fh_put 10691da177e4SLinus Torvalds */ 10706264d69dSAl Viro __be32 107152e380e0SKinglong Mee nfsd_write(struct svc_rqst *rqstp, struct svc_fh *fhp, loff_t offset, 107219e0663fSTrond Myklebust struct kvec *vec, int vlen, unsigned long *cnt, int stable, 107319e0663fSTrond Myklebust __be32 *verf) 10741da177e4SLinus Torvalds { 1075b4935239SJeff Layton struct nfsd_file *nf; 1076b4935239SJeff Layton __be32 err; 10771da177e4SLinus Torvalds 1078f394b62bSChuck Lever trace_nfsd_write_start(rqstp, fhp, offset, *cnt); 10796e8b50d1SJeff Layton 1080b4935239SJeff Layton err = nfsd_file_acquire(rqstp, fhp, NFSD_MAY_WRITE, &nf); 10811da177e4SLinus Torvalds if (err) 10821da177e4SLinus Torvalds goto out; 10831da177e4SLinus Torvalds 108416f8f894STrond Myklebust err = nfsd_vfs_write(rqstp, fhp, nf, offset, vec, 108519e0663fSTrond Myklebust vlen, cnt, stable, verf); 1086b4935239SJeff Layton nfsd_file_put(nf); 10871da177e4SLinus Torvalds out: 1088f394b62bSChuck Lever trace_nfsd_write_done(rqstp, fhp, offset, *cnt); 10891da177e4SLinus Torvalds return err; 10901da177e4SLinus Torvalds } 10911da177e4SLinus Torvalds 10921da177e4SLinus Torvalds #ifdef CONFIG_NFSD_V3 10931da177e4SLinus Torvalds /* 10941da177e4SLinus Torvalds * Commit all pending writes to stable storage. 1095aa696a6fSTrond Myklebust * 1096aa696a6fSTrond Myklebust * Note: we only guarantee that data that lies within the range specified 1097aa696a6fSTrond Myklebust * by the 'offset' and 'count' parameters will be synced. 10981da177e4SLinus Torvalds * 10991da177e4SLinus Torvalds * Unfortunately we cannot lock the file to make sure we return full WCC 11001da177e4SLinus Torvalds * data to the client, as locking happens lower down in the filesystem. 11011da177e4SLinus Torvalds */ 11026264d69dSAl Viro __be32 11031da177e4SLinus Torvalds nfsd_commit(struct svc_rqst *rqstp, struct svc_fh *fhp, 1104524ff1afSTrond Myklebust loff_t offset, unsigned long count, __be32 *verf) 11051da177e4SLinus Torvalds { 1106*2c445a0eSChuck Lever struct nfsd_net *nn; 11075920afa3SJeff Layton struct nfsd_file *nf; 1108aa696a6fSTrond Myklebust loff_t end = LLONG_MAX; 1109aa696a6fSTrond Myklebust __be32 err = nfserr_inval; 11101da177e4SLinus Torvalds 1111aa696a6fSTrond Myklebust if (offset < 0) 1112aa696a6fSTrond Myklebust goto out; 1113aa696a6fSTrond Myklebust if (count != 0) { 1114aa696a6fSTrond Myklebust end = offset + (loff_t)count - 1; 1115aa696a6fSTrond Myklebust if (end < offset) 1116aa696a6fSTrond Myklebust goto out; 1117aa696a6fSTrond Myklebust } 11181da177e4SLinus Torvalds 11195920afa3SJeff Layton err = nfsd_file_acquire(rqstp, fhp, 11205920afa3SJeff Layton NFSD_MAY_WRITE|NFSD_MAY_NOT_BREAK_LEASE, &nf); 11218837abcaSMiklos Szeredi if (err) 1122aa696a6fSTrond Myklebust goto out; 1123*2c445a0eSChuck Lever nn = net_generic(nf->nf_net, nfsd_net_id); 11241da177e4SLinus Torvalds if (EX_ISSYNC(fhp->fh_export)) { 1125555dbf1aSTrond Myklebust errseq_t since = READ_ONCE(nf->nf_file->f_wb_err); 1126555dbf1aSTrond Myklebust int err2; 1127aa696a6fSTrond Myklebust 11285011af4cSTrond Myklebust err2 = vfs_fsync_range(nf->nf_file, offset, end, 0); 1129bbf2f098STrond Myklebust switch (err2) { 1130bbf2f098STrond Myklebust case 0: 1131*2c445a0eSChuck Lever nfsd_copy_boot_verifier(verf, nn); 1132555dbf1aSTrond Myklebust err2 = filemap_check_wb_err(nf->nf_file->f_mapping, 1133555dbf1aSTrond Myklebust since); 1134bbf2f098STrond Myklebust break; 1135bbf2f098STrond Myklebust case -EINVAL: 11361da177e4SLinus Torvalds err = nfserr_notsupp; 1137bbf2f098STrond Myklebust break; 1138bbf2f098STrond Myklebust default: 1139*2c445a0eSChuck Lever nfsd_reset_boot_verifier(nn); 1140bbf2f098STrond Myklebust } 1141555dbf1aSTrond Myklebust err = nfserrno(err2); 1142524ff1afSTrond Myklebust } else 1143*2c445a0eSChuck Lever nfsd_copy_boot_verifier(verf, nn); 11441da177e4SLinus Torvalds 11455920afa3SJeff Layton nfsd_file_put(nf); 1146aa696a6fSTrond Myklebust out: 11471da177e4SLinus Torvalds return err; 11481da177e4SLinus Torvalds } 11491da177e4SLinus Torvalds #endif /* CONFIG_NFSD_V3 */ 11501da177e4SLinus Torvalds 1151f2b0dee2SAdrian Bunk static __be32 11525c002b3bSJ. Bruce Fields nfsd_create_setattr(struct svc_rqst *rqstp, struct svc_fh *resfhp, 11535c002b3bSJ. Bruce Fields struct iattr *iap) 11545c002b3bSJ. Bruce Fields { 11555c002b3bSJ. Bruce Fields /* 11565c002b3bSJ. Bruce Fields * Mode has already been set earlier in create: 11575c002b3bSJ. Bruce Fields */ 11585c002b3bSJ. Bruce Fields iap->ia_valid &= ~ATTR_MODE; 11595c002b3bSJ. Bruce Fields /* 11605c002b3bSJ. Bruce Fields * Setting uid/gid works only for root. Irix appears to 11615c002b3bSJ. Bruce Fields * send along the gid on create when it tries to implement 11625c002b3bSJ. Bruce Fields * setgid directories via NFS: 11635c002b3bSJ. Bruce Fields */ 11646fab8779SEric W. Biederman if (!uid_eq(current_fsuid(), GLOBAL_ROOT_UID)) 11655c002b3bSJ. Bruce Fields iap->ia_valid &= ~(ATTR_UID|ATTR_GID); 11665c002b3bSJ. Bruce Fields if (iap->ia_valid) 11672a1aa489SArnd Bergmann return nfsd_setattr(rqstp, resfhp, iap, 0, (time64_t)0); 11680f3a24b4STrond Myklebust /* Callers expect file metadata to be committed here */ 1169722b620dSJeff Layton return nfserrno(commit_metadata(resfhp)); 11705c002b3bSJ. Bruce Fields } 11715c002b3bSJ. Bruce Fields 11724ac35c2fSwengang wang /* HPUX client sometimes creates a file in mode 000, and sets size to 0. 11734ac35c2fSwengang wang * setting size to 0 may fail for some specific file systems by the permission 11744ac35c2fSwengang wang * checking which requires WRITE permission but the mode is 000. 11754ac35c2fSwengang wang * we ignore the resizing(to 0) on the just new created file, since the size is 11764ac35c2fSwengang wang * 0 after file created. 11774ac35c2fSwengang wang * 11784ac35c2fSwengang wang * call this only after vfs_create() is called. 11794ac35c2fSwengang wang * */ 11804ac35c2fSwengang wang static void 11814ac35c2fSwengang wang nfsd_check_ignore_resizing(struct iattr *iap) 11824ac35c2fSwengang wang { 11834ac35c2fSwengang wang if ((iap->ia_valid & ATTR_SIZE) && (iap->ia_size == 0)) 11844ac35c2fSwengang wang iap->ia_valid &= ~ATTR_SIZE; 11854ac35c2fSwengang wang } 11864ac35c2fSwengang wang 1187b44061d0SJ. Bruce Fields /* The parent directory should already be locked: */ 11886264d69dSAl Viro __be32 1189b44061d0SJ. Bruce Fields nfsd_create_locked(struct svc_rqst *rqstp, struct svc_fh *fhp, 11901da177e4SLinus Torvalds char *fname, int flen, struct iattr *iap, 11911da177e4SLinus Torvalds int type, dev_t rdev, struct svc_fh *resfhp) 11921da177e4SLinus Torvalds { 11932b118859SDan Carpenter struct dentry *dentry, *dchild; 11941da177e4SLinus Torvalds struct inode *dirp; 11956264d69dSAl Viro __be32 err; 11965c002b3bSJ. Bruce Fields __be32 err2; 11976264d69dSAl Viro int host_err; 11981da177e4SLinus Torvalds 11991da177e4SLinus Torvalds dentry = fhp->fh_dentry; 12002b0143b5SDavid Howells dirp = d_inode(dentry); 12011da177e4SLinus Torvalds 12021da177e4SLinus Torvalds dchild = dget(resfhp->fh_dentry); 12031da177e4SLinus Torvalds if (!fhp->fh_locked) { 1204b44061d0SJ. Bruce Fields WARN_ONCE(1, "nfsd_create: parent %pd2 not locked!\n", 1205a6a9f18fSAl Viro dentry); 1206d75f2b9fSAl Viro err = nfserr_io; 12071da177e4SLinus Torvalds goto out; 12081da177e4SLinus Torvalds } 12091da177e4SLinus Torvalds 12107eed34f1SOleg Drokin err = nfsd_permission(rqstp, fhp->fh_export, dentry, NFSD_MAY_CREATE); 12117eed34f1SOleg Drokin if (err) 12127eed34f1SOleg Drokin goto out; 12137eed34f1SOleg Drokin 12141da177e4SLinus Torvalds if (!(iap->ia_valid & ATTR_MODE)) 12151da177e4SLinus Torvalds iap->ia_mode = 0; 12161da177e4SLinus Torvalds iap->ia_mode = (iap->ia_mode & S_IALLUGO) | type; 12171da177e4SLinus Torvalds 121822cf8419SJ. Bruce Fields if (!IS_POSIXACL(dirp)) 121922cf8419SJ. Bruce Fields iap->ia_mode &= ~current_umask(); 122022cf8419SJ. Bruce Fields 1221088406bcSJ. Bruce Fields err = 0; 12224a55c101SJan Kara host_err = 0; 12231da177e4SLinus Torvalds switch (type) { 12241da177e4SLinus Torvalds case S_IFREG: 12256521f891SChristian Brauner host_err = vfs_create(&init_user_ns, dirp, dchild, iap->ia_mode, true); 12264ac35c2fSwengang wang if (!host_err) 12274ac35c2fSwengang wang nfsd_check_ignore_resizing(iap); 12281da177e4SLinus Torvalds break; 12291da177e4SLinus Torvalds case S_IFDIR: 12306521f891SChristian Brauner host_err = vfs_mkdir(&init_user_ns, dirp, dchild, iap->ia_mode); 12313819bb0dSAl Viro if (!host_err && unlikely(d_unhashed(dchild))) { 12323819bb0dSAl Viro struct dentry *d; 12333819bb0dSAl Viro d = lookup_one_len(dchild->d_name.name, 12343819bb0dSAl Viro dchild->d_parent, 12353819bb0dSAl Viro dchild->d_name.len); 12363819bb0dSAl Viro if (IS_ERR(d)) { 12373819bb0dSAl Viro host_err = PTR_ERR(d); 12383819bb0dSAl Viro break; 12393819bb0dSAl Viro } 12403819bb0dSAl Viro if (unlikely(d_is_negative(d))) { 12413819bb0dSAl Viro dput(d); 12423819bb0dSAl Viro err = nfserr_serverfault; 12433819bb0dSAl Viro goto out; 12443819bb0dSAl Viro } 12453819bb0dSAl Viro dput(resfhp->fh_dentry); 12463819bb0dSAl Viro resfhp->fh_dentry = dget(d); 12473819bb0dSAl Viro err = fh_update(resfhp); 12483819bb0dSAl Viro dput(dchild); 12493819bb0dSAl Viro dchild = d; 12503819bb0dSAl Viro if (err) 12513819bb0dSAl Viro goto out; 12523819bb0dSAl Viro } 12531da177e4SLinus Torvalds break; 12541da177e4SLinus Torvalds case S_IFCHR: 12551da177e4SLinus Torvalds case S_IFBLK: 12561da177e4SLinus Torvalds case S_IFIFO: 12571da177e4SLinus Torvalds case S_IFSOCK: 12586521f891SChristian Brauner host_err = vfs_mknod(&init_user_ns, dirp, dchild, 12596521f891SChristian Brauner iap->ia_mode, rdev); 12601da177e4SLinus Torvalds break; 126171423274SJ. Bruce Fields default: 126271423274SJ. Bruce Fields printk(KERN_WARNING "nfsd: bad file type %o in nfsd_create\n", 126371423274SJ. Bruce Fields type); 126471423274SJ. Bruce Fields host_err = -EINVAL; 1265463c3197SDave Hansen } 12664a55c101SJan Kara if (host_err < 0) 1267463c3197SDave Hansen goto out_nfserr; 12681da177e4SLinus Torvalds 1269f501912aSBen Myers err = nfsd_create_setattr(rqstp, resfhp, iap); 12701da177e4SLinus Torvalds 1271f501912aSBen Myers /* 12720f3a24b4STrond Myklebust * nfsd_create_setattr already committed the child. Transactional 12730f3a24b4STrond Myklebust * filesystems had a chance to commit changes for both parent and 1274b44061d0SJ. Bruce Fields * child simultaneously making the following commit_metadata a 12750f3a24b4STrond Myklebust * noop. 1276f501912aSBen Myers */ 1277f501912aSBen Myers err2 = nfserrno(commit_metadata(fhp)); 1278f193fbabSYAMAMOTO Takashi if (err2) 1279f193fbabSYAMAMOTO Takashi err = err2; 12801da177e4SLinus Torvalds /* 12811da177e4SLinus Torvalds * Update the file handle to get the new inode info. 12821da177e4SLinus Torvalds */ 12831da177e4SLinus Torvalds if (!err) 12841da177e4SLinus Torvalds err = fh_update(resfhp); 12851da177e4SLinus Torvalds out: 12861da177e4SLinus Torvalds dput(dchild); 12871da177e4SLinus Torvalds return err; 12881da177e4SLinus Torvalds 12891da177e4SLinus Torvalds out_nfserr: 12906264d69dSAl Viro err = nfserrno(host_err); 12911da177e4SLinus Torvalds goto out; 12921da177e4SLinus Torvalds } 12931da177e4SLinus Torvalds 1294b44061d0SJ. Bruce Fields /* 1295b44061d0SJ. Bruce Fields * Create a filesystem object (regular, directory, special). 1296b44061d0SJ. Bruce Fields * Note that the parent directory is left locked. 1297b44061d0SJ. Bruce Fields * 1298b44061d0SJ. Bruce Fields * N.B. Every call to nfsd_create needs an fh_put for _both_ fhp and resfhp 1299b44061d0SJ. Bruce Fields */ 1300b44061d0SJ. Bruce Fields __be32 1301b44061d0SJ. Bruce Fields nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp, 1302b44061d0SJ. Bruce Fields char *fname, int flen, struct iattr *iap, 1303b44061d0SJ. Bruce Fields int type, dev_t rdev, struct svc_fh *resfhp) 1304b44061d0SJ. Bruce Fields { 1305b44061d0SJ. Bruce Fields struct dentry *dentry, *dchild = NULL; 1306b44061d0SJ. Bruce Fields __be32 err; 1307b44061d0SJ. Bruce Fields int host_err; 1308b44061d0SJ. Bruce Fields 1309b44061d0SJ. Bruce Fields if (isdotent(fname, flen)) 1310b44061d0SJ. Bruce Fields return nfserr_exist; 1311b44061d0SJ. Bruce Fields 1312fa08139dSJ. Bruce Fields err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_NOP); 1313b44061d0SJ. Bruce Fields if (err) 1314b44061d0SJ. Bruce Fields return err; 1315b44061d0SJ. Bruce Fields 1316b44061d0SJ. Bruce Fields dentry = fhp->fh_dentry; 1317b44061d0SJ. Bruce Fields 1318b44061d0SJ. Bruce Fields host_err = fh_want_write(fhp); 1319b44061d0SJ. Bruce Fields if (host_err) 1320b44061d0SJ. Bruce Fields return nfserrno(host_err); 1321b44061d0SJ. Bruce Fields 1322b44061d0SJ. Bruce Fields fh_lock_nested(fhp, I_MUTEX_PARENT); 1323b44061d0SJ. Bruce Fields dchild = lookup_one_len(fname, dentry, flen); 1324b44061d0SJ. Bruce Fields host_err = PTR_ERR(dchild); 1325b44061d0SJ. Bruce Fields if (IS_ERR(dchild)) 1326b44061d0SJ. Bruce Fields return nfserrno(host_err); 1327b44061d0SJ. Bruce Fields err = fh_compose(resfhp, fhp->fh_export, dchild, fhp); 1328502aa0a5SJosef Bacik /* 1329502aa0a5SJosef Bacik * We unconditionally drop our ref to dchild as fh_compose will have 1330502aa0a5SJosef Bacik * already grabbed its own ref for it. 1331502aa0a5SJosef Bacik */ 1332b44061d0SJ. Bruce Fields dput(dchild); 1333502aa0a5SJosef Bacik if (err) 1334b44061d0SJ. Bruce Fields return err; 1335b44061d0SJ. Bruce Fields return nfsd_create_locked(rqstp, fhp, fname, flen, iap, type, 1336b44061d0SJ. Bruce Fields rdev, resfhp); 1337b44061d0SJ. Bruce Fields } 1338b44061d0SJ. Bruce Fields 13391da177e4SLinus Torvalds #ifdef CONFIG_NFSD_V3 1340ac6721a1SMi Jinlong 13411da177e4SLinus Torvalds /* 1342ac6721a1SMi Jinlong * NFSv3 and NFSv4 version of nfsd_create 13431da177e4SLinus Torvalds */ 13446264d69dSAl Viro __be32 1345ac6721a1SMi Jinlong do_nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp, 13461da177e4SLinus Torvalds char *fname, int flen, struct iattr *iap, 13471da177e4SLinus Torvalds struct svc_fh *resfhp, int createmode, u32 *verifier, 1348856121b2SJ. Bruce Fields bool *truncp, bool *created) 13491da177e4SLinus Torvalds { 13501da177e4SLinus Torvalds struct dentry *dentry, *dchild = NULL; 13511da177e4SLinus Torvalds struct inode *dirp; 13526264d69dSAl Viro __be32 err; 13536264d69dSAl Viro int host_err; 13541da177e4SLinus Torvalds __u32 v_mtime=0, v_atime=0; 13551da177e4SLinus Torvalds 13561da177e4SLinus Torvalds err = nfserr_perm; 13571da177e4SLinus Torvalds if (!flen) 13581da177e4SLinus Torvalds goto out; 13591da177e4SLinus Torvalds err = nfserr_exist; 13601da177e4SLinus Torvalds if (isdotent(fname, flen)) 13611da177e4SLinus Torvalds goto out; 13621da177e4SLinus Torvalds if (!(iap->ia_valid & ATTR_MODE)) 13631da177e4SLinus Torvalds iap->ia_mode = 0; 13641574dff8SSachin Prabhu err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_EXEC); 13651da177e4SLinus Torvalds if (err) 13661da177e4SLinus Torvalds goto out; 13671da177e4SLinus Torvalds 13681da177e4SLinus Torvalds dentry = fhp->fh_dentry; 13692b0143b5SDavid Howells dirp = d_inode(dentry); 13701da177e4SLinus Torvalds 13714a55c101SJan Kara host_err = fh_want_write(fhp); 13724a55c101SJan Kara if (host_err) 13734a55c101SJan Kara goto out_nfserr; 13744a55c101SJan Kara 137512fd3520SPeter Zijlstra fh_lock_nested(fhp, I_MUTEX_PARENT); 13761da177e4SLinus Torvalds 13771da177e4SLinus Torvalds /* 13781da177e4SLinus Torvalds * Compose the response file handle. 13791da177e4SLinus Torvalds */ 13801da177e4SLinus Torvalds dchild = lookup_one_len(fname, dentry, flen); 13816264d69dSAl Viro host_err = PTR_ERR(dchild); 13821da177e4SLinus Torvalds if (IS_ERR(dchild)) 13831da177e4SLinus Torvalds goto out_nfserr; 13841da177e4SLinus Torvalds 13851574dff8SSachin Prabhu /* If file doesn't exist, check for permissions to create one */ 13862b0143b5SDavid Howells if (d_really_is_negative(dchild)) { 13871574dff8SSachin Prabhu err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE); 13881574dff8SSachin Prabhu if (err) 13891574dff8SSachin Prabhu goto out; 13901574dff8SSachin Prabhu } 13911574dff8SSachin Prabhu 13921da177e4SLinus Torvalds err = fh_compose(resfhp, fhp->fh_export, dchild, fhp); 13931da177e4SLinus Torvalds if (err) 13941da177e4SLinus Torvalds goto out; 13951da177e4SLinus Torvalds 1396ac6721a1SMi Jinlong if (nfsd_create_is_exclusive(createmode)) { 1397c397852cSPeter Staubach /* solaris7 gets confused (bugid 4218508) if these have 13982336d696SJ. Bruce Fields * the high bit set, as do xfs filesystems without the 13992336d696SJ. Bruce Fields * "bigtime" feature. So just clear the high bits. If this is 1400749997e5SJeff Layton * ever changed to use different attrs for storing the 1401749997e5SJeff Layton * verifier, then do_open_lookup() will also need to be fixed 1402749997e5SJeff Layton * accordingly. 14031da177e4SLinus Torvalds */ 14041da177e4SLinus Torvalds v_mtime = verifier[0]&0x7fffffff; 14051da177e4SLinus Torvalds v_atime = verifier[1]&0x7fffffff; 14061da177e4SLinus Torvalds } 14071da177e4SLinus Torvalds 14082b0143b5SDavid Howells if (d_really_is_positive(dchild)) { 14091da177e4SLinus Torvalds err = 0; 14101da177e4SLinus Torvalds 14111da177e4SLinus Torvalds switch (createmode) { 14121da177e4SLinus Torvalds case NFS3_CREATE_UNCHECKED: 1413e36cb0b8SDavid Howells if (! d_is_reg(dchild)) 14149dc4e6c4SJ. Bruce Fields goto out; 14151da177e4SLinus Torvalds else if (truncp) { 14161da177e4SLinus Torvalds /* in nfsv4, we need to treat this case a little 14171da177e4SLinus Torvalds * differently. we don't want to truncate the 14181da177e4SLinus Torvalds * file now; this would be wrong if the OPEN 14191da177e4SLinus Torvalds * fails for some other reason. furthermore, 14201da177e4SLinus Torvalds * if the size is nonzero, we should ignore it 14211da177e4SLinus Torvalds * according to spec! 14221da177e4SLinus Torvalds */ 14231da177e4SLinus Torvalds *truncp = (iap->ia_valid & ATTR_SIZE) && !iap->ia_size; 14241da177e4SLinus Torvalds } 14251da177e4SLinus Torvalds else { 14261da177e4SLinus Torvalds iap->ia_valid &= ATTR_SIZE; 14271da177e4SLinus Torvalds goto set_attr; 14281da177e4SLinus Torvalds } 14291da177e4SLinus Torvalds break; 14301da177e4SLinus Torvalds case NFS3_CREATE_EXCLUSIVE: 14312b0143b5SDavid Howells if ( d_inode(dchild)->i_mtime.tv_sec == v_mtime 14322b0143b5SDavid Howells && d_inode(dchild)->i_atime.tv_sec == v_atime 14332b0143b5SDavid Howells && d_inode(dchild)->i_size == 0 ) { 14347007c90fSNeil Brown if (created) 1435384a7ccaSzhengbin *created = true; 14361da177e4SLinus Torvalds break; 14377007c90fSNeil Brown } 1438df561f66SGustavo A. R. Silva fallthrough; 1439ac6721a1SMi Jinlong case NFS4_CREATE_EXCLUSIVE4_1: 14402b0143b5SDavid Howells if ( d_inode(dchild)->i_mtime.tv_sec == v_mtime 14412b0143b5SDavid Howells && d_inode(dchild)->i_atime.tv_sec == v_atime 14422b0143b5SDavid Howells && d_inode(dchild)->i_size == 0 ) { 14437007c90fSNeil Brown if (created) 1444384a7ccaSzhengbin *created = true; 1445ac6721a1SMi Jinlong goto set_attr; 14467007c90fSNeil Brown } 1447df561f66SGustavo A. R. Silva fallthrough; 14481da177e4SLinus Torvalds case NFS3_CREATE_GUARDED: 14491da177e4SLinus Torvalds err = nfserr_exist; 14501da177e4SLinus Torvalds } 1451bad0dcffSAl Viro fh_drop_write(fhp); 14521da177e4SLinus Torvalds goto out; 14531da177e4SLinus Torvalds } 14541da177e4SLinus Torvalds 145522cf8419SJ. Bruce Fields if (!IS_POSIXACL(dirp)) 145622cf8419SJ. Bruce Fields iap->ia_mode &= ~current_umask(); 145722cf8419SJ. Bruce Fields 14586521f891SChristian Brauner host_err = vfs_create(&init_user_ns, dirp, dchild, iap->ia_mode, true); 1459463c3197SDave Hansen if (host_err < 0) { 1460bad0dcffSAl Viro fh_drop_write(fhp); 14611da177e4SLinus Torvalds goto out_nfserr; 1462463c3197SDave Hansen } 146381ac95c5SJ. Bruce Fields if (created) 1464384a7ccaSzhengbin *created = true; 14651da177e4SLinus Torvalds 14664ac35c2fSwengang wang nfsd_check_ignore_resizing(iap); 14674ac35c2fSwengang wang 1468ac6721a1SMi Jinlong if (nfsd_create_is_exclusive(createmode)) { 1469c397852cSPeter Staubach /* Cram the verifier into atime/mtime */ 14701da177e4SLinus Torvalds iap->ia_valid = ATTR_MTIME|ATTR_ATIME 1471c397852cSPeter Staubach | ATTR_MTIME_SET|ATTR_ATIME_SET; 14721da177e4SLinus Torvalds /* XXX someone who knows this better please fix it for nsec */ 14731da177e4SLinus Torvalds iap->ia_mtime.tv_sec = v_mtime; 14741da177e4SLinus Torvalds iap->ia_atime.tv_sec = v_atime; 14751da177e4SLinus Torvalds iap->ia_mtime.tv_nsec = 0; 14761da177e4SLinus Torvalds iap->ia_atime.tv_nsec = 0; 14771da177e4SLinus Torvalds } 14781da177e4SLinus Torvalds 14791da177e4SLinus Torvalds set_attr: 1480f501912aSBen Myers err = nfsd_create_setattr(rqstp, resfhp, iap); 1481f501912aSBen Myers 1482f501912aSBen Myers /* 14830f3a24b4STrond Myklebust * nfsd_create_setattr already committed the child 14840f3a24b4STrond Myklebust * (and possibly also the parent). 1485f501912aSBen Myers */ 1486f501912aSBen Myers if (!err) 1487f501912aSBen Myers err = nfserrno(commit_metadata(fhp)); 1488f193fbabSYAMAMOTO Takashi 1489f193fbabSYAMAMOTO Takashi /* 1490f193fbabSYAMAMOTO Takashi * Update the filehandle to get the new inode info. 1491f193fbabSYAMAMOTO Takashi */ 1492f193fbabSYAMAMOTO Takashi if (!err) 1493f193fbabSYAMAMOTO Takashi err = fh_update(resfhp); 14941da177e4SLinus Torvalds 14951da177e4SLinus Torvalds out: 14961da177e4SLinus Torvalds fh_unlock(fhp); 14971da177e4SLinus Torvalds if (dchild && !IS_ERR(dchild)) 14981da177e4SLinus Torvalds dput(dchild); 14994a55c101SJan Kara fh_drop_write(fhp); 15001da177e4SLinus Torvalds return err; 15011da177e4SLinus Torvalds 15021da177e4SLinus Torvalds out_nfserr: 15036264d69dSAl Viro err = nfserrno(host_err); 15041da177e4SLinus Torvalds goto out; 15051da177e4SLinus Torvalds } 15061da177e4SLinus Torvalds #endif /* CONFIG_NFSD_V3 */ 15071da177e4SLinus Torvalds 15081da177e4SLinus Torvalds /* 15091da177e4SLinus Torvalds * Read a symlink. On entry, *lenp must contain the maximum path length that 15101da177e4SLinus Torvalds * fits into the buffer. On return, it contains the true length. 15111da177e4SLinus Torvalds * N.B. After this call fhp needs an fh_put 15121da177e4SLinus Torvalds */ 15136264d69dSAl Viro __be32 15141da177e4SLinus Torvalds nfsd_readlink(struct svc_rqst *rqstp, struct svc_fh *fhp, char *buf, int *lenp) 15151da177e4SLinus Torvalds { 15166264d69dSAl Viro __be32 err; 15174d7edbc3SAl Viro const char *link; 151868ac1234SAl Viro struct path path; 15194d7edbc3SAl Viro DEFINE_DELAYED_CALL(done); 15204d7edbc3SAl Viro int len; 15211da177e4SLinus Torvalds 15228837abcaSMiklos Szeredi err = fh_verify(rqstp, fhp, S_IFLNK, NFSD_MAY_NOP); 15234d7edbc3SAl Viro if (unlikely(err)) 15244d7edbc3SAl Viro return err; 15251da177e4SLinus Torvalds 152668ac1234SAl Viro path.mnt = fhp->fh_export->ex_path.mnt; 152768ac1234SAl Viro path.dentry = fhp->fh_dentry; 15281da177e4SLinus Torvalds 15294d7edbc3SAl Viro if (unlikely(!d_is_symlink(path.dentry))) 15304d7edbc3SAl Viro return nfserr_inval; 15311da177e4SLinus Torvalds 153268ac1234SAl Viro touch_atime(&path); 15331da177e4SLinus Torvalds 15344d7edbc3SAl Viro link = vfs_get_link(path.dentry, &done); 15354d7edbc3SAl Viro if (IS_ERR(link)) 15364d7edbc3SAl Viro return nfserrno(PTR_ERR(link)); 15371da177e4SLinus Torvalds 15384d7edbc3SAl Viro len = strlen(link); 15394d7edbc3SAl Viro if (len < *lenp) 15404d7edbc3SAl Viro *lenp = len; 15414d7edbc3SAl Viro memcpy(buf, link, *lenp); 15424d7edbc3SAl Viro do_delayed_call(&done); 15434d7edbc3SAl Viro return 0; 15441da177e4SLinus Torvalds } 15451da177e4SLinus Torvalds 15461da177e4SLinus Torvalds /* 15471da177e4SLinus Torvalds * Create a symlink and look up its inode 15481da177e4SLinus Torvalds * N.B. After this call _both_ fhp and resfhp need an fh_put 15491da177e4SLinus Torvalds */ 15506264d69dSAl Viro __be32 15511da177e4SLinus Torvalds nfsd_symlink(struct svc_rqst *rqstp, struct svc_fh *fhp, 15521da177e4SLinus Torvalds char *fname, int flen, 155352ee0433SJ. Bruce Fields char *path, 15541e444f5bSKinglong Mee struct svc_fh *resfhp) 15551da177e4SLinus Torvalds { 15561da177e4SLinus Torvalds struct dentry *dentry, *dnew; 15576264d69dSAl Viro __be32 err, cerr; 15586264d69dSAl Viro int host_err; 15591da177e4SLinus Torvalds 15601da177e4SLinus Torvalds err = nfserr_noent; 156152ee0433SJ. Bruce Fields if (!flen || path[0] == '\0') 15621da177e4SLinus Torvalds goto out; 15631da177e4SLinus Torvalds err = nfserr_exist; 15641da177e4SLinus Torvalds if (isdotent(fname, flen)) 15651da177e4SLinus Torvalds goto out; 15661da177e4SLinus Torvalds 15678837abcaSMiklos Szeredi err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE); 15681da177e4SLinus Torvalds if (err) 15691da177e4SLinus Torvalds goto out; 15704a55c101SJan Kara 15714a55c101SJan Kara host_err = fh_want_write(fhp); 15724a55c101SJan Kara if (host_err) 15734a55c101SJan Kara goto out_nfserr; 15744a55c101SJan Kara 15751da177e4SLinus Torvalds fh_lock(fhp); 15761da177e4SLinus Torvalds dentry = fhp->fh_dentry; 15771da177e4SLinus Torvalds dnew = lookup_one_len(fname, dentry, flen); 15786264d69dSAl Viro host_err = PTR_ERR(dnew); 15791da177e4SLinus Torvalds if (IS_ERR(dnew)) 15801da177e4SLinus Torvalds goto out_nfserr; 15811da177e4SLinus Torvalds 15826521f891SChristian Brauner host_err = vfs_symlink(&init_user_ns, d_inode(dentry), dnew, path); 15836264d69dSAl Viro err = nfserrno(host_err); 1584eeeadbb9SJ. Bruce Fields fh_unlock(fhp); 1585f501912aSBen Myers if (!err) 1586f501912aSBen Myers err = nfserrno(commit_metadata(fhp)); 15871da177e4SLinus Torvalds 1588bad0dcffSAl Viro fh_drop_write(fhp); 158975c3f29dSDave Hansen 15901da177e4SLinus Torvalds cerr = fh_compose(resfhp, fhp->fh_export, dnew, fhp); 15911da177e4SLinus Torvalds dput(dnew); 15921da177e4SLinus Torvalds if (err==0) err = cerr; 15931da177e4SLinus Torvalds out: 15941da177e4SLinus Torvalds return err; 15951da177e4SLinus Torvalds 15961da177e4SLinus Torvalds out_nfserr: 15976264d69dSAl Viro err = nfserrno(host_err); 15981da177e4SLinus Torvalds goto out; 15991da177e4SLinus Torvalds } 16001da177e4SLinus Torvalds 16011da177e4SLinus Torvalds /* 16021da177e4SLinus Torvalds * Create a hardlink 16031da177e4SLinus Torvalds * N.B. After this call _both_ ffhp and tfhp need an fh_put 16041da177e4SLinus Torvalds */ 16056264d69dSAl Viro __be32 16061da177e4SLinus Torvalds nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp, 16071da177e4SLinus Torvalds char *name, int len, struct svc_fh *tfhp) 16081da177e4SLinus Torvalds { 16091da177e4SLinus Torvalds struct dentry *ddir, *dnew, *dold; 161055b13354SJ. Bruce Fields struct inode *dirp; 16116264d69dSAl Viro __be32 err; 16126264d69dSAl Viro int host_err; 16131da177e4SLinus Torvalds 16148837abcaSMiklos Szeredi err = fh_verify(rqstp, ffhp, S_IFDIR, NFSD_MAY_CREATE); 16151da177e4SLinus Torvalds if (err) 16161da177e4SLinus Torvalds goto out; 16177d818a7bSJ. Bruce Fields err = fh_verify(rqstp, tfhp, 0, NFSD_MAY_NOP); 16181da177e4SLinus Torvalds if (err) 16191da177e4SLinus Torvalds goto out; 16207d818a7bSJ. Bruce Fields err = nfserr_isdir; 1621e36cb0b8SDavid Howells if (d_is_dir(tfhp->fh_dentry)) 16227d818a7bSJ. Bruce Fields goto out; 16231da177e4SLinus Torvalds err = nfserr_perm; 16241da177e4SLinus Torvalds if (!len) 16251da177e4SLinus Torvalds goto out; 16261da177e4SLinus Torvalds err = nfserr_exist; 16271da177e4SLinus Torvalds if (isdotent(name, len)) 16281da177e4SLinus Torvalds goto out; 16291da177e4SLinus Torvalds 16304a55c101SJan Kara host_err = fh_want_write(tfhp); 16314a55c101SJan Kara if (host_err) { 16324a55c101SJan Kara err = nfserrno(host_err); 16334a55c101SJan Kara goto out; 16344a55c101SJan Kara } 16354a55c101SJan Kara 163612fd3520SPeter Zijlstra fh_lock_nested(ffhp, I_MUTEX_PARENT); 16371da177e4SLinus Torvalds ddir = ffhp->fh_dentry; 16382b0143b5SDavid Howells dirp = d_inode(ddir); 16391da177e4SLinus Torvalds 16401da177e4SLinus Torvalds dnew = lookup_one_len(name, ddir, len); 16416264d69dSAl Viro host_err = PTR_ERR(dnew); 16421da177e4SLinus Torvalds if (IS_ERR(dnew)) 16431da177e4SLinus Torvalds goto out_nfserr; 16441da177e4SLinus Torvalds 16451da177e4SLinus Torvalds dold = tfhp->fh_dentry; 16461da177e4SLinus Torvalds 16474795bb37SJ. Bruce Fields err = nfserr_noent; 16482b0143b5SDavid Howells if (d_really_is_negative(dold)) 16494a55c101SJan Kara goto out_dput; 16506521f891SChristian Brauner host_err = vfs_link(dold, &init_user_ns, dirp, dnew, NULL); 1651eeeadbb9SJ. Bruce Fields fh_unlock(ffhp); 16526264d69dSAl Viro if (!host_err) { 1653f501912aSBen Myers err = nfserrno(commit_metadata(ffhp)); 1654f501912aSBen Myers if (!err) 1655f501912aSBen Myers err = nfserrno(commit_metadata(tfhp)); 16561da177e4SLinus Torvalds } else { 16576264d69dSAl Viro if (host_err == -EXDEV && rqstp->rq_vers == 2) 16581da177e4SLinus Torvalds err = nfserr_acces; 16591da177e4SLinus Torvalds else 16606264d69dSAl Viro err = nfserrno(host_err); 16611da177e4SLinus Torvalds } 166275c3f29dSDave Hansen out_dput: 16631da177e4SLinus Torvalds dput(dnew); 1664270d56e5SDavid M. Richter out_unlock: 1665270d56e5SDavid M. Richter fh_unlock(ffhp); 16664a55c101SJan Kara fh_drop_write(tfhp); 16671da177e4SLinus Torvalds out: 16681da177e4SLinus Torvalds return err; 16691da177e4SLinus Torvalds 16701da177e4SLinus Torvalds out_nfserr: 16716264d69dSAl Viro err = nfserrno(host_err); 1672270d56e5SDavid M. Richter goto out_unlock; 16731da177e4SLinus Torvalds } 16741da177e4SLinus Torvalds 16757775ec57SJeff Layton static void 16767775ec57SJeff Layton nfsd_close_cached_files(struct dentry *dentry) 16777775ec57SJeff Layton { 16787775ec57SJeff Layton struct inode *inode = d_inode(dentry); 16797775ec57SJeff Layton 16807775ec57SJeff Layton if (inode && S_ISREG(inode->i_mode)) 16817775ec57SJeff Layton nfsd_file_close_inode_sync(inode); 16827775ec57SJeff Layton } 16837775ec57SJeff Layton 16847775ec57SJeff Layton static bool 16857775ec57SJeff Layton nfsd_has_cached_files(struct dentry *dentry) 16867775ec57SJeff Layton { 16877775ec57SJeff Layton bool ret = false; 16887775ec57SJeff Layton struct inode *inode = d_inode(dentry); 16897775ec57SJeff Layton 16907775ec57SJeff Layton if (inode && S_ISREG(inode->i_mode)) 16917775ec57SJeff Layton ret = nfsd_file_is_cached(inode); 16927775ec57SJeff Layton return ret; 16937775ec57SJeff Layton } 16947775ec57SJeff Layton 16951da177e4SLinus Torvalds /* 16961da177e4SLinus Torvalds * Rename a file 16971da177e4SLinus Torvalds * N.B. After this call _both_ ffhp and tfhp need an fh_put 16981da177e4SLinus Torvalds */ 16996264d69dSAl Viro __be32 17001da177e4SLinus Torvalds nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen, 17011da177e4SLinus Torvalds struct svc_fh *tfhp, char *tname, int tlen) 17021da177e4SLinus Torvalds { 17031da177e4SLinus Torvalds struct dentry *fdentry, *tdentry, *odentry, *ndentry, *trap; 17041da177e4SLinus Torvalds struct inode *fdir, *tdir; 17056264d69dSAl Viro __be32 err; 17066264d69dSAl Viro int host_err; 17077f84b488SJeff Layton bool close_cached = false; 17081da177e4SLinus Torvalds 17098837abcaSMiklos Szeredi err = fh_verify(rqstp, ffhp, S_IFDIR, NFSD_MAY_REMOVE); 17101da177e4SLinus Torvalds if (err) 17111da177e4SLinus Torvalds goto out; 17128837abcaSMiklos Szeredi err = fh_verify(rqstp, tfhp, S_IFDIR, NFSD_MAY_CREATE); 17131da177e4SLinus Torvalds if (err) 17141da177e4SLinus Torvalds goto out; 17151da177e4SLinus Torvalds 17161da177e4SLinus Torvalds fdentry = ffhp->fh_dentry; 17172b0143b5SDavid Howells fdir = d_inode(fdentry); 17181da177e4SLinus Torvalds 17191da177e4SLinus Torvalds tdentry = tfhp->fh_dentry; 17202b0143b5SDavid Howells tdir = d_inode(tdentry); 17211da177e4SLinus Torvalds 17221da177e4SLinus Torvalds err = nfserr_perm; 17231da177e4SLinus Torvalds if (!flen || isdotent(fname, flen) || !tlen || isdotent(tname, tlen)) 17241da177e4SLinus Torvalds goto out; 17251da177e4SLinus Torvalds 17267775ec57SJeff Layton retry: 17274a55c101SJan Kara host_err = fh_want_write(ffhp); 17284a55c101SJan Kara if (host_err) { 17294a55c101SJan Kara err = nfserrno(host_err); 17304a55c101SJan Kara goto out; 17314a55c101SJan Kara } 17324a55c101SJan Kara 17331da177e4SLinus Torvalds /* cannot use fh_lock as we need deadlock protective ordering 17341da177e4SLinus Torvalds * so do it by hand */ 17351da177e4SLinus Torvalds trap = lock_rename(tdentry, fdentry); 1736aaf91ec1SJeff Layton ffhp->fh_locked = tfhp->fh_locked = true; 17371da177e4SLinus Torvalds fill_pre_wcc(ffhp); 17381da177e4SLinus Torvalds fill_pre_wcc(tfhp); 17391da177e4SLinus Torvalds 17401da177e4SLinus Torvalds odentry = lookup_one_len(fname, fdentry, flen); 17416264d69dSAl Viro host_err = PTR_ERR(odentry); 17421da177e4SLinus Torvalds if (IS_ERR(odentry)) 17431da177e4SLinus Torvalds goto out_nfserr; 17441da177e4SLinus Torvalds 17456264d69dSAl Viro host_err = -ENOENT; 17462b0143b5SDavid Howells if (d_really_is_negative(odentry)) 17471da177e4SLinus Torvalds goto out_dput_old; 17486264d69dSAl Viro host_err = -EINVAL; 17491da177e4SLinus Torvalds if (odentry == trap) 17501da177e4SLinus Torvalds goto out_dput_old; 17511da177e4SLinus Torvalds 17521da177e4SLinus Torvalds ndentry = lookup_one_len(tname, tdentry, tlen); 17536264d69dSAl Viro host_err = PTR_ERR(ndentry); 17541da177e4SLinus Torvalds if (IS_ERR(ndentry)) 17551da177e4SLinus Torvalds goto out_dput_old; 17566264d69dSAl Viro host_err = -ENOTEMPTY; 17571da177e4SLinus Torvalds if (ndentry == trap) 17581da177e4SLinus Torvalds goto out_dput_new; 17591da177e4SLinus Torvalds 17609079b1ebSDave Hansen host_err = -EXDEV; 17619079b1ebSDave Hansen if (ffhp->fh_export->ex_path.mnt != tfhp->fh_export->ex_path.mnt) 17629079b1ebSDave Hansen goto out_dput_new; 1763aa387d6cSJ. Bruce Fields if (ffhp->fh_export->ex_path.dentry != tfhp->fh_export->ex_path.dentry) 1764aa387d6cSJ. Bruce Fields goto out_dput_new; 17659079b1ebSDave Hansen 17667f84b488SJeff Layton if ((ndentry->d_sb->s_export_op->flags & EXPORT_OP_CLOSE_BEFORE_UNLINK) && 17677f84b488SJeff Layton nfsd_has_cached_files(ndentry)) { 17687f84b488SJeff Layton close_cached = true; 17697775ec57SJeff Layton goto out_dput_old; 17707775ec57SJeff Layton } else { 17719fe61450SChristian Brauner struct renamedata rd = { 17726521f891SChristian Brauner .old_mnt_userns = &init_user_ns, 17739fe61450SChristian Brauner .old_dir = fdir, 17749fe61450SChristian Brauner .old_dentry = odentry, 17756521f891SChristian Brauner .new_mnt_userns = &init_user_ns, 17769fe61450SChristian Brauner .new_dir = tdir, 17779fe61450SChristian Brauner .new_dentry = ndentry, 17789fe61450SChristian Brauner }; 17799fe61450SChristian Brauner host_err = vfs_rename(&rd); 1780f501912aSBen Myers if (!host_err) { 1781f501912aSBen Myers host_err = commit_metadata(tfhp); 17826264d69dSAl Viro if (!host_err) 1783f501912aSBen Myers host_err = commit_metadata(ffhp); 17841da177e4SLinus Torvalds } 17857775ec57SJeff Layton } 17861da177e4SLinus Torvalds out_dput_new: 17871da177e4SLinus Torvalds dput(ndentry); 17881da177e4SLinus Torvalds out_dput_old: 17891da177e4SLinus Torvalds dput(odentry); 17901da177e4SLinus Torvalds out_nfserr: 17916264d69dSAl Viro err = nfserrno(host_err); 1792fbb74a34SJ. Bruce Fields /* 1793fbb74a34SJ. Bruce Fields * We cannot rely on fh_unlock on the two filehandles, 17941da177e4SLinus Torvalds * as that would do the wrong thing if the two directories 1795fbb74a34SJ. Bruce Fields * were the same, so again we do it by hand. 17961da177e4SLinus Torvalds */ 17977f84b488SJeff Layton if (!close_cached) { 17981da177e4SLinus Torvalds fill_post_wcc(ffhp); 17991da177e4SLinus Torvalds fill_post_wcc(tfhp); 18007775ec57SJeff Layton } 18011da177e4SLinus Torvalds unlock_rename(tdentry, fdentry); 1802aaf91ec1SJeff Layton ffhp->fh_locked = tfhp->fh_locked = false; 18034a55c101SJan Kara fh_drop_write(ffhp); 18041da177e4SLinus Torvalds 18057775ec57SJeff Layton /* 18067775ec57SJeff Layton * If the target dentry has cached open files, then we need to try to 18077775ec57SJeff Layton * close them prior to doing the rename. Flushing delayed fput 18087775ec57SJeff Layton * shouldn't be done with locks held however, so we delay it until this 18097775ec57SJeff Layton * point and then reattempt the whole shebang. 18107775ec57SJeff Layton */ 18117f84b488SJeff Layton if (close_cached) { 18127f84b488SJeff Layton close_cached = false; 18137775ec57SJeff Layton nfsd_close_cached_files(ndentry); 18147775ec57SJeff Layton dput(ndentry); 18157775ec57SJeff Layton goto retry; 18167775ec57SJeff Layton } 18171da177e4SLinus Torvalds out: 18181da177e4SLinus Torvalds return err; 18191da177e4SLinus Torvalds } 18201da177e4SLinus Torvalds 18211da177e4SLinus Torvalds /* 18221da177e4SLinus Torvalds * Unlink a file or directory 18231da177e4SLinus Torvalds * N.B. After this call fhp needs an fh_put 18241da177e4SLinus Torvalds */ 18256264d69dSAl Viro __be32 18261da177e4SLinus Torvalds nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type, 18271da177e4SLinus Torvalds char *fname, int flen) 18281da177e4SLinus Torvalds { 18291da177e4SLinus Torvalds struct dentry *dentry, *rdentry; 18301da177e4SLinus Torvalds struct inode *dirp; 1831e5d74a2dSYu Hsiang Huang struct inode *rinode; 18326264d69dSAl Viro __be32 err; 18336264d69dSAl Viro int host_err; 18341da177e4SLinus Torvalds 18351da177e4SLinus Torvalds err = nfserr_acces; 18361da177e4SLinus Torvalds if (!flen || isdotent(fname, flen)) 18371da177e4SLinus Torvalds goto out; 18388837abcaSMiklos Szeredi err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_REMOVE); 18391da177e4SLinus Torvalds if (err) 18401da177e4SLinus Torvalds goto out; 18411da177e4SLinus Torvalds 18424a55c101SJan Kara host_err = fh_want_write(fhp); 18434a55c101SJan Kara if (host_err) 18444a55c101SJan Kara goto out_nfserr; 18454a55c101SJan Kara 184612fd3520SPeter Zijlstra fh_lock_nested(fhp, I_MUTEX_PARENT); 18471da177e4SLinus Torvalds dentry = fhp->fh_dentry; 18482b0143b5SDavid Howells dirp = d_inode(dentry); 18491da177e4SLinus Torvalds 18501da177e4SLinus Torvalds rdentry = lookup_one_len(fname, dentry, flen); 18516264d69dSAl Viro host_err = PTR_ERR(rdentry); 18521da177e4SLinus Torvalds if (IS_ERR(rdentry)) 18530ca0c9d7SJ. Bruce Fields goto out_drop_write; 18541da177e4SLinus Torvalds 18552b0143b5SDavid Howells if (d_really_is_negative(rdentry)) { 18561da177e4SLinus Torvalds dput(rdentry); 18570ca0c9d7SJ. Bruce Fields host_err = -ENOENT; 18580ca0c9d7SJ. Bruce Fields goto out_drop_write; 18591da177e4SLinus Torvalds } 1860e5d74a2dSYu Hsiang Huang rinode = d_inode(rdentry); 1861e5d74a2dSYu Hsiang Huang ihold(rinode); 18621da177e4SLinus Torvalds 18631da177e4SLinus Torvalds if (!type) 18642b0143b5SDavid Howells type = d_inode(rdentry)->i_mode & S_IFMT; 18651da177e4SLinus Torvalds 18667775ec57SJeff Layton if (type != S_IFDIR) { 18677f84b488SJeff Layton if (rdentry->d_sb->s_export_op->flags & EXPORT_OP_CLOSE_BEFORE_UNLINK) 18687775ec57SJeff Layton nfsd_close_cached_files(rdentry); 18696521f891SChristian Brauner host_err = vfs_unlink(&init_user_ns, dirp, rdentry, NULL); 18707775ec57SJeff Layton } else { 18716521f891SChristian Brauner host_err = vfs_rmdir(&init_user_ns, dirp, rdentry); 18727775ec57SJeff Layton } 18737775ec57SJeff Layton 1874eeeadbb9SJ. Bruce Fields fh_unlock(fhp); 1875541ce98cSJ. Bruce Fields if (!host_err) 1876541ce98cSJ. Bruce Fields host_err = commit_metadata(fhp); 18771da177e4SLinus Torvalds dput(rdentry); 1878e5d74a2dSYu Hsiang Huang iput(rinode); /* truncate the inode here */ 18791da177e4SLinus Torvalds 18800ca0c9d7SJ. Bruce Fields out_drop_write: 18810ca0c9d7SJ. Bruce Fields fh_drop_write(fhp); 18821da177e4SLinus Torvalds out_nfserr: 1883466e16f0SNeilBrown if (host_err == -EBUSY) { 1884466e16f0SNeilBrown /* name is mounted-on. There is no perfect 1885466e16f0SNeilBrown * error status. 1886466e16f0SNeilBrown */ 1887466e16f0SNeilBrown if (nfsd_v4client(rqstp)) 1888466e16f0SNeilBrown err = nfserr_file_open; 1889466e16f0SNeilBrown else 1890466e16f0SNeilBrown err = nfserr_acces; 1891466e16f0SNeilBrown } else { 18926264d69dSAl Viro err = nfserrno(host_err); 1893466e16f0SNeilBrown } 1894f193fbabSYAMAMOTO Takashi out: 1895f193fbabSYAMAMOTO Takashi return err; 18961da177e4SLinus Torvalds } 18971da177e4SLinus Torvalds 18981da177e4SLinus Torvalds /* 189914f7dd63SDavid Woodhouse * We do this buffering because we must not call back into the file 190014f7dd63SDavid Woodhouse * system's ->lookup() method from the filldir callback. That may well 190114f7dd63SDavid Woodhouse * deadlock a number of file systems. 190214f7dd63SDavid Woodhouse * 190314f7dd63SDavid Woodhouse * This is based heavily on the implementation of same in XFS. 190414f7dd63SDavid Woodhouse */ 190514f7dd63SDavid Woodhouse struct buffered_dirent { 190614f7dd63SDavid Woodhouse u64 ino; 190714f7dd63SDavid Woodhouse loff_t offset; 190814f7dd63SDavid Woodhouse int namlen; 190914f7dd63SDavid Woodhouse unsigned int d_type; 191014f7dd63SDavid Woodhouse char name[]; 191114f7dd63SDavid Woodhouse }; 191214f7dd63SDavid Woodhouse 191314f7dd63SDavid Woodhouse struct readdir_data { 19145c0ba4e0SAl Viro struct dir_context ctx; 191514f7dd63SDavid Woodhouse char *dirent; 191614f7dd63SDavid Woodhouse size_t used; 191753c9c5c0SAl Viro int full; 191814f7dd63SDavid Woodhouse }; 191914f7dd63SDavid Woodhouse 1920ac7576f4SMiklos Szeredi static int nfsd_buffered_filldir(struct dir_context *ctx, const char *name, 1921ac7576f4SMiklos Szeredi int namlen, loff_t offset, u64 ino, 1922ac7576f4SMiklos Szeredi unsigned int d_type) 192314f7dd63SDavid Woodhouse { 1924ac7576f4SMiklos Szeredi struct readdir_data *buf = 1925ac7576f4SMiklos Szeredi container_of(ctx, struct readdir_data, ctx); 192614f7dd63SDavid Woodhouse struct buffered_dirent *de = (void *)(buf->dirent + buf->used); 192714f7dd63SDavid Woodhouse unsigned int reclen; 192814f7dd63SDavid Woodhouse 192914f7dd63SDavid Woodhouse reclen = ALIGN(sizeof(struct buffered_dirent) + namlen, sizeof(u64)); 193053c9c5c0SAl Viro if (buf->used + reclen > PAGE_SIZE) { 193153c9c5c0SAl Viro buf->full = 1; 193214f7dd63SDavid Woodhouse return -EINVAL; 193353c9c5c0SAl Viro } 193414f7dd63SDavid Woodhouse 193514f7dd63SDavid Woodhouse de->namlen = namlen; 193614f7dd63SDavid Woodhouse de->offset = offset; 193714f7dd63SDavid Woodhouse de->ino = ino; 193814f7dd63SDavid Woodhouse de->d_type = d_type; 193914f7dd63SDavid Woodhouse memcpy(de->name, name, namlen); 194014f7dd63SDavid Woodhouse buf->used += reclen; 194114f7dd63SDavid Woodhouse 194214f7dd63SDavid Woodhouse return 0; 194314f7dd63SDavid Woodhouse } 194414f7dd63SDavid Woodhouse 19456019ce07SChuck Lever static __be32 nfsd_buffered_readdir(struct file *file, struct svc_fh *fhp, 19466019ce07SChuck Lever nfsd_filldir_t func, struct readdir_cd *cdp, 19476019ce07SChuck Lever loff_t *offsetp) 19482628b766SDavid Woodhouse { 194914f7dd63SDavid Woodhouse struct buffered_dirent *de; 19502628b766SDavid Woodhouse int host_err; 195114f7dd63SDavid Woodhouse int size; 195214f7dd63SDavid Woodhouse loff_t offset; 1953ac6614b7SAl Viro struct readdir_data buf = { 1954ac6614b7SAl Viro .ctx.actor = nfsd_buffered_filldir, 1955ac6614b7SAl Viro .dirent = (void *)__get_free_page(GFP_KERNEL) 1956ac6614b7SAl Viro }; 19572628b766SDavid Woodhouse 195814f7dd63SDavid Woodhouse if (!buf.dirent) 19592f9092e1SDavid Woodhouse return nfserrno(-ENOMEM); 196014f7dd63SDavid Woodhouse 196114f7dd63SDavid Woodhouse offset = *offsetp; 19622628b766SDavid Woodhouse 196314f7dd63SDavid Woodhouse while (1) { 196414f7dd63SDavid Woodhouse unsigned int reclen; 196514f7dd63SDavid Woodhouse 1966b726e923SDoug Nazar cdp->err = nfserr_eof; /* will be cleared on successful read */ 196714f7dd63SDavid Woodhouse buf.used = 0; 196853c9c5c0SAl Viro buf.full = 0; 196914f7dd63SDavid Woodhouse 19705c0ba4e0SAl Viro host_err = iterate_dir(file, &buf.ctx); 197153c9c5c0SAl Viro if (buf.full) 197253c9c5c0SAl Viro host_err = 0; 197353c9c5c0SAl Viro 197453c9c5c0SAl Viro if (host_err < 0) 197514f7dd63SDavid Woodhouse break; 197614f7dd63SDavid Woodhouse 197714f7dd63SDavid Woodhouse size = buf.used; 197814f7dd63SDavid Woodhouse 197914f7dd63SDavid Woodhouse if (!size) 198014f7dd63SDavid Woodhouse break; 198114f7dd63SDavid Woodhouse 198214f7dd63SDavid Woodhouse de = (struct buffered_dirent *)buf.dirent; 198314f7dd63SDavid Woodhouse while (size > 0) { 198414f7dd63SDavid Woodhouse offset = de->offset; 198514f7dd63SDavid Woodhouse 198614f7dd63SDavid Woodhouse if (func(cdp, de->name, de->namlen, de->offset, 198714f7dd63SDavid Woodhouse de->ino, de->d_type)) 19882f9092e1SDavid Woodhouse break; 198914f7dd63SDavid Woodhouse 199014f7dd63SDavid Woodhouse if (cdp->err != nfs_ok) 19912f9092e1SDavid Woodhouse break; 199214f7dd63SDavid Woodhouse 19936019ce07SChuck Lever trace_nfsd_dirent(fhp, de->ino, de->name, de->namlen); 19946019ce07SChuck Lever 199514f7dd63SDavid Woodhouse reclen = ALIGN(sizeof(*de) + de->namlen, 199614f7dd63SDavid Woodhouse sizeof(u64)); 199714f7dd63SDavid Woodhouse size -= reclen; 199814f7dd63SDavid Woodhouse de = (struct buffered_dirent *)((char *)de + reclen); 199914f7dd63SDavid Woodhouse } 20002f9092e1SDavid Woodhouse if (size > 0) /* We bailed out early */ 20012f9092e1SDavid Woodhouse break; 20022f9092e1SDavid Woodhouse 2003c002a6c7SDavid Woodhouse offset = vfs_llseek(file, 0, SEEK_CUR); 200414f7dd63SDavid Woodhouse } 200514f7dd63SDavid Woodhouse 200614f7dd63SDavid Woodhouse free_page((unsigned long)(buf.dirent)); 20072628b766SDavid Woodhouse 20082628b766SDavid Woodhouse if (host_err) 20092628b766SDavid Woodhouse return nfserrno(host_err); 201014f7dd63SDavid Woodhouse 201114f7dd63SDavid Woodhouse *offsetp = offset; 20122628b766SDavid Woodhouse return cdp->err; 20132628b766SDavid Woodhouse } 20142628b766SDavid Woodhouse 20151da177e4SLinus Torvalds /* 20161da177e4SLinus Torvalds * Read entries from a directory. 20171da177e4SLinus Torvalds * The NFSv3/4 verifier we ignore for now. 20181da177e4SLinus Torvalds */ 20196264d69dSAl Viro __be32 20201da177e4SLinus Torvalds nfsd_readdir(struct svc_rqst *rqstp, struct svc_fh *fhp, loff_t *offsetp, 2021ac7576f4SMiklos Szeredi struct readdir_cd *cdp, nfsd_filldir_t func) 20221da177e4SLinus Torvalds { 20236264d69dSAl Viro __be32 err; 20241da177e4SLinus Torvalds struct file *file; 20251da177e4SLinus Torvalds loff_t offset = *offsetp; 202606effdbbSBernd Schubert int may_flags = NFSD_MAY_READ; 20271da177e4SLinus Torvalds 202806effdbbSBernd Schubert /* NFSv2 only supports 32 bit cookies */ 202906effdbbSBernd Schubert if (rqstp->rq_vers > 2) 203006effdbbSBernd Schubert may_flags |= NFSD_MAY_64BIT_COOKIE; 203106effdbbSBernd Schubert 203206effdbbSBernd Schubert err = nfsd_open(rqstp, fhp, S_IFDIR, may_flags, &file); 20331da177e4SLinus Torvalds if (err) 20341da177e4SLinus Torvalds goto out; 20351da177e4SLinus Torvalds 2036b108fe6bSJeff Layton offset = vfs_llseek(file, offset, SEEK_SET); 20371da177e4SLinus Torvalds if (offset < 0) { 20381da177e4SLinus Torvalds err = nfserrno((int)offset); 20391da177e4SLinus Torvalds goto out_close; 20401da177e4SLinus Torvalds } 20411da177e4SLinus Torvalds 20426019ce07SChuck Lever err = nfsd_buffered_readdir(file, fhp, func, cdp, offsetp); 20431da177e4SLinus Torvalds 20441da177e4SLinus Torvalds if (err == nfserr_eof || err == nfserr_toosmall) 20451da177e4SLinus Torvalds err = nfs_ok; /* can still be found in ->err */ 20461da177e4SLinus Torvalds out_close: 2047fd891454SChristoph Hellwig fput(file); 20481da177e4SLinus Torvalds out: 20491da177e4SLinus Torvalds return err; 20501da177e4SLinus Torvalds } 20511da177e4SLinus Torvalds 20521da177e4SLinus Torvalds /* 20531da177e4SLinus Torvalds * Get file system stats 20541da177e4SLinus Torvalds * N.B. After this call fhp needs an fh_put 20551da177e4SLinus Torvalds */ 20566264d69dSAl Viro __be32 205704716e66SJ. Bruce Fields nfsd_statfs(struct svc_rqst *rqstp, struct svc_fh *fhp, struct kstatfs *stat, int access) 20581da177e4SLinus Torvalds { 2059f6360efbSTakashi Iwai __be32 err; 2060f6360efbSTakashi Iwai 2061f6360efbSTakashi Iwai err = fh_verify(rqstp, fhp, 0, NFSD_MAY_NOP | access); 2062f6360efbSTakashi Iwai if (!err) { 2063ebabe9a9SChristoph Hellwig struct path path = { 2064ebabe9a9SChristoph Hellwig .mnt = fhp->fh_export->ex_path.mnt, 2065ebabe9a9SChristoph Hellwig .dentry = fhp->fh_dentry, 2066ebabe9a9SChristoph Hellwig }; 2067f6360efbSTakashi Iwai if (vfs_statfs(&path, stat)) 20681da177e4SLinus Torvalds err = nfserr_io; 2069f6360efbSTakashi Iwai } 20701da177e4SLinus Torvalds return err; 20711da177e4SLinus Torvalds } 20721da177e4SLinus Torvalds 2073c7d51402SJ. Bruce Fields static int exp_rdonly(struct svc_rqst *rqstp, struct svc_export *exp) 2074e22841c6SJ. Bruce Fields { 2075c7d51402SJ. Bruce Fields return nfsexp_flags(rqstp, exp) & NFSEXP_READONLY; 2076e22841c6SJ. Bruce Fields } 2077e22841c6SJ. Bruce Fields 207832119446SFrank van der Linden #ifdef CONFIG_NFSD_V4 207932119446SFrank van der Linden /* 208032119446SFrank van der Linden * Helper function to translate error numbers. In the case of xattr operations, 208132119446SFrank van der Linden * some error codes need to be translated outside of the standard translations. 208232119446SFrank van der Linden * 208332119446SFrank van der Linden * ENODATA needs to be translated to nfserr_noxattr. 208432119446SFrank van der Linden * E2BIG to nfserr_xattr2big. 208532119446SFrank van der Linden * 208632119446SFrank van der Linden * Additionally, vfs_listxattr can return -ERANGE. This means that the 208732119446SFrank van der Linden * file has too many extended attributes to retrieve inside an 208832119446SFrank van der Linden * XATTR_LIST_MAX sized buffer. This is a bug in the xattr implementation: 208932119446SFrank van der Linden * filesystems will allow the adding of extended attributes until they hit 209032119446SFrank van der Linden * their own internal limit. This limit may be larger than XATTR_LIST_MAX. 209132119446SFrank van der Linden * So, at that point, the attributes are present and valid, but can't 209232119446SFrank van der Linden * be retrieved using listxattr, since the upper level xattr code enforces 209332119446SFrank van der Linden * the XATTR_LIST_MAX limit. 209432119446SFrank van der Linden * 209532119446SFrank van der Linden * This bug means that we need to deal with listxattr returning -ERANGE. The 209632119446SFrank van der Linden * best mapping is to return TOOSMALL. 209732119446SFrank van der Linden */ 209832119446SFrank van der Linden static __be32 209932119446SFrank van der Linden nfsd_xattr_errno(int err) 210032119446SFrank van der Linden { 210132119446SFrank van der Linden switch (err) { 210232119446SFrank van der Linden case -ENODATA: 210332119446SFrank van der Linden return nfserr_noxattr; 210432119446SFrank van der Linden case -E2BIG: 210532119446SFrank van der Linden return nfserr_xattr2big; 210632119446SFrank van der Linden case -ERANGE: 210732119446SFrank van der Linden return nfserr_toosmall; 210832119446SFrank van der Linden } 210932119446SFrank van der Linden return nfserrno(err); 211032119446SFrank van der Linden } 211132119446SFrank van der Linden 211232119446SFrank van der Linden /* 211332119446SFrank van der Linden * Retrieve the specified user extended attribute. To avoid always 211432119446SFrank van der Linden * having to allocate the maximum size (since we are not getting 211532119446SFrank van der Linden * a maximum size from the RPC), do a probe + alloc. Hold a reader 211632119446SFrank van der Linden * lock on i_rwsem to prevent the extended attribute from changing 211732119446SFrank van der Linden * size while we're doing this. 211832119446SFrank van der Linden */ 211932119446SFrank van der Linden __be32 212032119446SFrank van der Linden nfsd_getxattr(struct svc_rqst *rqstp, struct svc_fh *fhp, char *name, 212132119446SFrank van der Linden void **bufp, int *lenp) 212232119446SFrank van der Linden { 212332119446SFrank van der Linden ssize_t len; 212432119446SFrank van der Linden __be32 err; 212532119446SFrank van der Linden char *buf; 212632119446SFrank van der Linden struct inode *inode; 212732119446SFrank van der Linden struct dentry *dentry; 212832119446SFrank van der Linden 212932119446SFrank van der Linden err = fh_verify(rqstp, fhp, 0, NFSD_MAY_READ); 213032119446SFrank van der Linden if (err) 213132119446SFrank van der Linden return err; 213232119446SFrank van der Linden 213332119446SFrank van der Linden err = nfs_ok; 213432119446SFrank van der Linden dentry = fhp->fh_dentry; 213532119446SFrank van der Linden inode = d_inode(dentry); 213632119446SFrank van der Linden 213732119446SFrank van der Linden inode_lock_shared(inode); 213832119446SFrank van der Linden 2139c7c7a1a1STycho Andersen len = vfs_getxattr(&init_user_ns, dentry, name, NULL, 0); 214032119446SFrank van der Linden 214132119446SFrank van der Linden /* 214232119446SFrank van der Linden * Zero-length attribute, just return. 214332119446SFrank van der Linden */ 214432119446SFrank van der Linden if (len == 0) { 214532119446SFrank van der Linden *bufp = NULL; 214632119446SFrank van der Linden *lenp = 0; 214732119446SFrank van der Linden goto out; 214832119446SFrank van der Linden } 214932119446SFrank van der Linden 215032119446SFrank van der Linden if (len < 0) { 215132119446SFrank van der Linden err = nfsd_xattr_errno(len); 215232119446SFrank van der Linden goto out; 215332119446SFrank van der Linden } 215432119446SFrank van der Linden 215532119446SFrank van der Linden if (len > *lenp) { 215632119446SFrank van der Linden err = nfserr_toosmall; 215732119446SFrank van der Linden goto out; 215832119446SFrank van der Linden } 215932119446SFrank van der Linden 216032119446SFrank van der Linden buf = kvmalloc(len, GFP_KERNEL | GFP_NOFS); 216132119446SFrank van der Linden if (buf == NULL) { 216232119446SFrank van der Linden err = nfserr_jukebox; 216332119446SFrank van der Linden goto out; 216432119446SFrank van der Linden } 216532119446SFrank van der Linden 2166c7c7a1a1STycho Andersen len = vfs_getxattr(&init_user_ns, dentry, name, buf, len); 216732119446SFrank van der Linden if (len <= 0) { 216832119446SFrank van der Linden kvfree(buf); 216932119446SFrank van der Linden buf = NULL; 217032119446SFrank van der Linden err = nfsd_xattr_errno(len); 217132119446SFrank van der Linden } 217232119446SFrank van der Linden 217332119446SFrank van der Linden *lenp = len; 217432119446SFrank van der Linden *bufp = buf; 217532119446SFrank van der Linden 217632119446SFrank van der Linden out: 217732119446SFrank van der Linden inode_unlock_shared(inode); 217832119446SFrank van der Linden 217932119446SFrank van der Linden return err; 218032119446SFrank van der Linden } 218132119446SFrank van der Linden 218232119446SFrank van der Linden /* 218332119446SFrank van der Linden * Retrieve the xattr names. Since we can't know how many are 218432119446SFrank van der Linden * user extended attributes, we must get all attributes here, 218532119446SFrank van der Linden * and have the XDR encode filter out the "user." ones. 218632119446SFrank van der Linden * 218732119446SFrank van der Linden * While this could always just allocate an XATTR_LIST_MAX 218832119446SFrank van der Linden * buffer, that's a waste, so do a probe + allocate. To 218932119446SFrank van der Linden * avoid any changes between the probe and allocate, wrap 219032119446SFrank van der Linden * this in inode_lock. 219132119446SFrank van der Linden */ 219232119446SFrank van der Linden __be32 219332119446SFrank van der Linden nfsd_listxattr(struct svc_rqst *rqstp, struct svc_fh *fhp, char **bufp, 219432119446SFrank van der Linden int *lenp) 219532119446SFrank van der Linden { 219632119446SFrank van der Linden ssize_t len; 219732119446SFrank van der Linden __be32 err; 219832119446SFrank van der Linden char *buf; 219932119446SFrank van der Linden struct inode *inode; 220032119446SFrank van der Linden struct dentry *dentry; 220132119446SFrank van der Linden 220232119446SFrank van der Linden err = fh_verify(rqstp, fhp, 0, NFSD_MAY_READ); 220332119446SFrank van der Linden if (err) 220432119446SFrank van der Linden return err; 220532119446SFrank van der Linden 220632119446SFrank van der Linden dentry = fhp->fh_dentry; 220732119446SFrank van der Linden inode = d_inode(dentry); 220832119446SFrank van der Linden *lenp = 0; 220932119446SFrank van der Linden 221032119446SFrank van der Linden inode_lock_shared(inode); 221132119446SFrank van der Linden 221232119446SFrank van der Linden len = vfs_listxattr(dentry, NULL, 0); 221332119446SFrank van der Linden if (len <= 0) { 221432119446SFrank van der Linden err = nfsd_xattr_errno(len); 221532119446SFrank van der Linden goto out; 221632119446SFrank van der Linden } 221732119446SFrank van der Linden 221832119446SFrank van der Linden if (len > XATTR_LIST_MAX) { 221932119446SFrank van der Linden err = nfserr_xattr2big; 222032119446SFrank van der Linden goto out; 222132119446SFrank van der Linden } 222232119446SFrank van der Linden 222332119446SFrank van der Linden /* 222432119446SFrank van der Linden * We're holding i_rwsem - use GFP_NOFS. 222532119446SFrank van der Linden */ 222632119446SFrank van der Linden buf = kvmalloc(len, GFP_KERNEL | GFP_NOFS); 222732119446SFrank van der Linden if (buf == NULL) { 222832119446SFrank van der Linden err = nfserr_jukebox; 222932119446SFrank van der Linden goto out; 223032119446SFrank van der Linden } 223132119446SFrank van der Linden 223232119446SFrank van der Linden len = vfs_listxattr(dentry, buf, len); 223332119446SFrank van der Linden if (len <= 0) { 223432119446SFrank van der Linden kvfree(buf); 223532119446SFrank van der Linden err = nfsd_xattr_errno(len); 223632119446SFrank van der Linden goto out; 223732119446SFrank van der Linden } 223832119446SFrank van der Linden 223932119446SFrank van der Linden *lenp = len; 224032119446SFrank van der Linden *bufp = buf; 224132119446SFrank van der Linden 224232119446SFrank van der Linden err = nfs_ok; 224332119446SFrank van der Linden out: 224432119446SFrank van der Linden inode_unlock_shared(inode); 224532119446SFrank van der Linden 224632119446SFrank van der Linden return err; 224732119446SFrank van der Linden } 224832119446SFrank van der Linden 224932119446SFrank van der Linden /* 225032119446SFrank van der Linden * Removexattr and setxattr need to call fh_lock to both lock the inode 225132119446SFrank van der Linden * and set the change attribute. Since the top-level vfs_removexattr 225232119446SFrank van der Linden * and vfs_setxattr calls already do their own inode_lock calls, call 225332119446SFrank van der Linden * the _locked variant. Pass in a NULL pointer for delegated_inode, 225432119446SFrank van der Linden * and let the client deal with NFS4ERR_DELAY (same as with e.g. 225532119446SFrank van der Linden * setattr and remove). 225632119446SFrank van der Linden */ 225732119446SFrank van der Linden __be32 225832119446SFrank van der Linden nfsd_removexattr(struct svc_rqst *rqstp, struct svc_fh *fhp, char *name) 225932119446SFrank van der Linden { 22608237284aSChuck Lever __be32 err; 22618237284aSChuck Lever int ret; 226232119446SFrank van der Linden 226332119446SFrank van der Linden err = fh_verify(rqstp, fhp, 0, NFSD_MAY_WRITE); 226432119446SFrank van der Linden if (err) 226532119446SFrank van der Linden return err; 226632119446SFrank van der Linden 226732119446SFrank van der Linden ret = fh_want_write(fhp); 226832119446SFrank van der Linden if (ret) 226932119446SFrank van der Linden return nfserrno(ret); 227032119446SFrank van der Linden 227132119446SFrank van der Linden fh_lock(fhp); 227232119446SFrank van der Linden 2273c7c7a1a1STycho Andersen ret = __vfs_removexattr_locked(&init_user_ns, fhp->fh_dentry, 2274c7c7a1a1STycho Andersen name, NULL); 227532119446SFrank van der Linden 227632119446SFrank van der Linden fh_unlock(fhp); 227732119446SFrank van der Linden fh_drop_write(fhp); 227832119446SFrank van der Linden 227932119446SFrank van der Linden return nfsd_xattr_errno(ret); 228032119446SFrank van der Linden } 228132119446SFrank van der Linden 228232119446SFrank van der Linden __be32 228332119446SFrank van der Linden nfsd_setxattr(struct svc_rqst *rqstp, struct svc_fh *fhp, char *name, 228432119446SFrank van der Linden void *buf, u32 len, u32 flags) 228532119446SFrank van der Linden { 22868237284aSChuck Lever __be32 err; 22878237284aSChuck Lever int ret; 228832119446SFrank van der Linden 228932119446SFrank van der Linden err = fh_verify(rqstp, fhp, 0, NFSD_MAY_WRITE); 229032119446SFrank van der Linden if (err) 229132119446SFrank van der Linden return err; 229232119446SFrank van der Linden 229332119446SFrank van der Linden ret = fh_want_write(fhp); 229432119446SFrank van der Linden if (ret) 229532119446SFrank van der Linden return nfserrno(ret); 229632119446SFrank van der Linden fh_lock(fhp); 229732119446SFrank van der Linden 2298c7c7a1a1STycho Andersen ret = __vfs_setxattr_locked(&init_user_ns, fhp->fh_dentry, name, buf, 2299c7c7a1a1STycho Andersen len, flags, NULL); 230032119446SFrank van der Linden 230132119446SFrank van der Linden fh_unlock(fhp); 230232119446SFrank van der Linden fh_drop_write(fhp); 230332119446SFrank van der Linden 230432119446SFrank van der Linden return nfsd_xattr_errno(ret); 230532119446SFrank van der Linden } 230632119446SFrank van der Linden #endif 230732119446SFrank van der Linden 23081da177e4SLinus Torvalds /* 23091da177e4SLinus Torvalds * Check for a user's access permissions to this inode. 23101da177e4SLinus Torvalds */ 23116264d69dSAl Viro __be32 23120ec757dfSJ. Bruce Fields nfsd_permission(struct svc_rqst *rqstp, struct svc_export *exp, 23130ec757dfSJ. Bruce Fields struct dentry *dentry, int acc) 23141da177e4SLinus Torvalds { 23152b0143b5SDavid Howells struct inode *inode = d_inode(dentry); 23161da177e4SLinus Torvalds int err; 23171da177e4SLinus Torvalds 2318aea93397SJ. Bruce Fields if ((acc & NFSD_MAY_MASK) == NFSD_MAY_NOP) 23191da177e4SLinus Torvalds return 0; 23201da177e4SLinus Torvalds #if 0 23211da177e4SLinus Torvalds dprintk("nfsd: permission 0x%x%s%s%s%s%s%s%s mode 0%o%s%s%s\n", 23221da177e4SLinus Torvalds acc, 23238837abcaSMiklos Szeredi (acc & NFSD_MAY_READ)? " read" : "", 23248837abcaSMiklos Szeredi (acc & NFSD_MAY_WRITE)? " write" : "", 23258837abcaSMiklos Szeredi (acc & NFSD_MAY_EXEC)? " exec" : "", 23268837abcaSMiklos Szeredi (acc & NFSD_MAY_SATTR)? " sattr" : "", 23278837abcaSMiklos Szeredi (acc & NFSD_MAY_TRUNC)? " trunc" : "", 23288837abcaSMiklos Szeredi (acc & NFSD_MAY_LOCK)? " lock" : "", 23298837abcaSMiklos Szeredi (acc & NFSD_MAY_OWNER_OVERRIDE)? " owneroverride" : "", 23301da177e4SLinus Torvalds inode->i_mode, 23311da177e4SLinus Torvalds IS_IMMUTABLE(inode)? " immut" : "", 23321da177e4SLinus Torvalds IS_APPEND(inode)? " append" : "", 23332c463e95SDave Hansen __mnt_is_readonly(exp->ex_path.mnt)? " ro" : ""); 23341da177e4SLinus Torvalds dprintk(" owner %d/%d user %d/%d\n", 23355cc0a840SDavid Howells inode->i_uid, inode->i_gid, current_fsuid(), current_fsgid()); 23361da177e4SLinus Torvalds #endif 23371da177e4SLinus Torvalds 23381da177e4SLinus Torvalds /* Normally we reject any write/sattr etc access on a read-only file 23391da177e4SLinus Torvalds * system. But if it is IRIX doing check on write-access for a 23401da177e4SLinus Torvalds * device special file, we ignore rofs. 23411da177e4SLinus Torvalds */ 23428837abcaSMiklos Szeredi if (!(acc & NFSD_MAY_LOCAL_ACCESS)) 23438837abcaSMiklos Szeredi if (acc & (NFSD_MAY_WRITE | NFSD_MAY_SATTR | NFSD_MAY_TRUNC)) { 23442c463e95SDave Hansen if (exp_rdonly(rqstp, exp) || 23452c463e95SDave Hansen __mnt_is_readonly(exp->ex_path.mnt)) 23461da177e4SLinus Torvalds return nfserr_rofs; 23478837abcaSMiklos Szeredi if (/* (acc & NFSD_MAY_WRITE) && */ IS_IMMUTABLE(inode)) 23481da177e4SLinus Torvalds return nfserr_perm; 23491da177e4SLinus Torvalds } 23508837abcaSMiklos Szeredi if ((acc & NFSD_MAY_TRUNC) && IS_APPEND(inode)) 23511da177e4SLinus Torvalds return nfserr_perm; 23521da177e4SLinus Torvalds 23538837abcaSMiklos Szeredi if (acc & NFSD_MAY_LOCK) { 23541da177e4SLinus Torvalds /* If we cannot rely on authentication in NLM requests, 23551da177e4SLinus Torvalds * just allow locks, otherwise require read permission, or 23561da177e4SLinus Torvalds * ownership 23571da177e4SLinus Torvalds */ 23581da177e4SLinus Torvalds if (exp->ex_flags & NFSEXP_NOAUTHNLM) 23591da177e4SLinus Torvalds return 0; 23601da177e4SLinus Torvalds else 23618837abcaSMiklos Szeredi acc = NFSD_MAY_READ | NFSD_MAY_OWNER_OVERRIDE; 23621da177e4SLinus Torvalds } 23631da177e4SLinus Torvalds /* 23641da177e4SLinus Torvalds * The file owner always gets access permission for accesses that 23651da177e4SLinus Torvalds * would normally be checked at open time. This is to make 23661da177e4SLinus Torvalds * file access work even when the client has done a fchmod(fd, 0). 23671da177e4SLinus Torvalds * 23681da177e4SLinus Torvalds * However, `cp foo bar' should fail nevertheless when bar is 23691da177e4SLinus Torvalds * readonly. A sensible way to do this might be to reject all 23701da177e4SLinus Torvalds * attempts to truncate a read-only file, because a creat() call 23711da177e4SLinus Torvalds * always implies file truncation. 23721da177e4SLinus Torvalds * ... but this isn't really fair. A process may reasonably call 23731da177e4SLinus Torvalds * ftruncate on an open file descriptor on a file with perm 000. 23741da177e4SLinus Torvalds * We must trust the client to do permission checking - using "ACCESS" 23751da177e4SLinus Torvalds * with NFSv3. 23761da177e4SLinus Torvalds */ 23778837abcaSMiklos Szeredi if ((acc & NFSD_MAY_OWNER_OVERRIDE) && 23786fab8779SEric W. Biederman uid_eq(inode->i_uid, current_fsuid())) 23791da177e4SLinus Torvalds return 0; 23801da177e4SLinus Torvalds 23818837abcaSMiklos Szeredi /* This assumes NFSD_MAY_{READ,WRITE,EXEC} == MAY_{READ,WRITE,EXEC} */ 238247291baaSChristian Brauner err = inode_permission(&init_user_ns, inode, 238347291baaSChristian Brauner acc & (MAY_READ | MAY_WRITE | MAY_EXEC)); 23841da177e4SLinus Torvalds 23851da177e4SLinus Torvalds /* Allow read access to binaries even when mode 111 */ 23861da177e4SLinus Torvalds if (err == -EACCES && S_ISREG(inode->i_mode) && 2387a043226bSJ. Bruce Fields (acc == (NFSD_MAY_READ | NFSD_MAY_OWNER_OVERRIDE) || 2388a043226bSJ. Bruce Fields acc == (NFSD_MAY_READ | NFSD_MAY_READ_IF_EXEC))) 238947291baaSChristian Brauner err = inode_permission(&init_user_ns, inode, MAY_EXEC); 23901da177e4SLinus Torvalds 23911da177e4SLinus Torvalds return err? nfserrno(err) : 0; 23921da177e4SLinus Torvalds } 2393