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>
29cbcc268bSMatthew Wilcox (Oracle) #include <linux/pagemap.h>
305a0e3ad6STejun Heo #include <linux/slab.h>
317c0f6ba6SLinus Torvalds #include <linux/uaccess.h>
32f501912aSBen Myers #include <linux/exportfs.h>
33f501912aSBen Myers #include <linux/writeback.h>
3418032ca0SDavid Quigley #include <linux/security.h>
359a74af21SBoaz Harrosh
369a74af21SBoaz Harrosh #include "xdr3.h"
379a74af21SBoaz Harrosh
385be196e5SChristoph Hellwig #ifdef CONFIG_NFSD_V4
39ffa0160aSChristoph Hellwig #include "../internal.h"
402ca72e17SJ. Bruce Fields #include "acl.h"
412ca72e17SJ. Bruce Fields #include "idmap.h"
42a2f4c3faSTrond Myklebust #include "xdr4.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
52cb12fae1SJeff Layton /**
53cb12fae1SJeff Layton * nfserrno - Map Linux errnos to NFS errnos
54cb12fae1SJeff Layton * @errno: POSIX(-ish) error code to be mapped
55cb12fae1SJeff Layton *
56cb12fae1SJeff Layton * Returns the appropriate (net-endian) nfserr_* (or nfs_ok if errno is 0). If
57cb12fae1SJeff Layton * it's an error we don't expect, log it once and return nfserr_io.
58cb12fae1SJeff Layton */
59cb12fae1SJeff Layton __be32
nfserrno(int errno)60cb12fae1SJeff Layton nfserrno (int errno)
61cb12fae1SJeff Layton {
62cb12fae1SJeff Layton static struct {
63cb12fae1SJeff Layton __be32 nfserr;
64cb12fae1SJeff Layton int syserr;
65cb12fae1SJeff Layton } nfs_errtbl[] = {
66cb12fae1SJeff Layton { nfs_ok, 0 },
67cb12fae1SJeff Layton { nfserr_perm, -EPERM },
68cb12fae1SJeff Layton { nfserr_noent, -ENOENT },
69cb12fae1SJeff Layton { nfserr_io, -EIO },
70cb12fae1SJeff Layton { nfserr_nxio, -ENXIO },
71cb12fae1SJeff Layton { nfserr_fbig, -E2BIG },
72cb12fae1SJeff Layton { nfserr_stale, -EBADF },
73cb12fae1SJeff Layton { nfserr_acces, -EACCES },
74cb12fae1SJeff Layton { nfserr_exist, -EEXIST },
75cb12fae1SJeff Layton { nfserr_xdev, -EXDEV },
76cb12fae1SJeff Layton { nfserr_mlink, -EMLINK },
77cb12fae1SJeff Layton { nfserr_nodev, -ENODEV },
78cb12fae1SJeff Layton { nfserr_notdir, -ENOTDIR },
79cb12fae1SJeff Layton { nfserr_isdir, -EISDIR },
80cb12fae1SJeff Layton { nfserr_inval, -EINVAL },
81cb12fae1SJeff Layton { nfserr_fbig, -EFBIG },
82cb12fae1SJeff Layton { nfserr_nospc, -ENOSPC },
83cb12fae1SJeff Layton { nfserr_rofs, -EROFS },
84cb12fae1SJeff Layton { nfserr_mlink, -EMLINK },
85cb12fae1SJeff Layton { nfserr_nametoolong, -ENAMETOOLONG },
86cb12fae1SJeff Layton { nfserr_notempty, -ENOTEMPTY },
87cb12fae1SJeff Layton { nfserr_dquot, -EDQUOT },
88cb12fae1SJeff Layton { nfserr_stale, -ESTALE },
89cb12fae1SJeff Layton { nfserr_jukebox, -ETIMEDOUT },
90cb12fae1SJeff Layton { nfserr_jukebox, -ERESTARTSYS },
91cb12fae1SJeff Layton { nfserr_jukebox, -EAGAIN },
92cb12fae1SJeff Layton { nfserr_jukebox, -EWOULDBLOCK },
93cb12fae1SJeff Layton { nfserr_jukebox, -ENOMEM },
94cb12fae1SJeff Layton { nfserr_io, -ETXTBSY },
95cb12fae1SJeff Layton { nfserr_notsupp, -EOPNOTSUPP },
96cb12fae1SJeff Layton { nfserr_toosmall, -ETOOSMALL },
97cb12fae1SJeff Layton { nfserr_serverfault, -ESERVERFAULT },
98cb12fae1SJeff Layton { nfserr_serverfault, -ENFILE },
99cb12fae1SJeff Layton { nfserr_io, -EREMOTEIO },
100cb12fae1SJeff Layton { nfserr_stale, -EOPENSTALE },
101cb12fae1SJeff Layton { nfserr_io, -EUCLEAN },
102cb12fae1SJeff Layton { nfserr_perm, -ENOKEY },
103cb12fae1SJeff Layton { nfserr_no_grace, -ENOGRACE},
104cb12fae1SJeff Layton };
105cb12fae1SJeff Layton int i;
106cb12fae1SJeff Layton
107cb12fae1SJeff Layton for (i = 0; i < ARRAY_SIZE(nfs_errtbl); i++) {
108cb12fae1SJeff Layton if (nfs_errtbl[i].syserr == errno)
109cb12fae1SJeff Layton return nfs_errtbl[i].nfserr;
110cb12fae1SJeff Layton }
111cb12fae1SJeff Layton WARN_ONCE(1, "nfsd: non-standard errno: %d\n", errno);
112cb12fae1SJeff Layton return nfserr_io;
113cb12fae1SJeff Layton }
114cb12fae1SJeff Layton
1151da177e4SLinus Torvalds /*
1161da177e4SLinus Torvalds * Called from nfsd_lookup and encode_dirent. Check if we have crossed
1171da177e4SLinus Torvalds * a mount point.
118e0bb89efSJ.Bruce Fields * Returns -EAGAIN or -ETIMEDOUT leaving *dpp and *expp unchanged,
1191da177e4SLinus Torvalds * or nfs_ok having possibly changed *dpp and *expp
1201da177e4SLinus Torvalds */
1211da177e4SLinus Torvalds int
nfsd_cross_mnt(struct svc_rqst * rqstp,struct dentry ** dpp,struct svc_export ** expp)1221da177e4SLinus Torvalds nfsd_cross_mnt(struct svc_rqst *rqstp, struct dentry **dpp,
1231da177e4SLinus Torvalds struct svc_export **expp)
1241da177e4SLinus Torvalds {
1251da177e4SLinus Torvalds struct svc_export *exp = *expp, *exp2 = NULL;
1261da177e4SLinus Torvalds struct dentry *dentry = *dpp;
12791c9fa8fSAl Viro struct path path = {.mnt = mntget(exp->ex_path.mnt),
12891c9fa8fSAl Viro .dentry = dget(dentry)};
129e1f19857SRichard Weinberger unsigned int follow_flags = 0;
1306264d69dSAl Viro int err = 0;
1311da177e4SLinus Torvalds
132e1f19857SRichard Weinberger if (exp->ex_flags & NFSEXP_CROSSMOUNT)
133e1f19857SRichard Weinberger follow_flags = LOOKUP_AUTOMOUNT;
134e1f19857SRichard Weinberger
135e1f19857SRichard Weinberger err = follow_down(&path, follow_flags);
136cc53ce53SDavid Howells if (err < 0)
137cc53ce53SDavid Howells goto out;
13899bbf6ecSNeilBrown if (path.mnt == exp->ex_path.mnt && path.dentry == dentry &&
13999bbf6ecSNeilBrown nfsd_mountpoint(dentry, exp) == 2) {
14099bbf6ecSNeilBrown /* This is only a mountpoint in some other namespace */
14199bbf6ecSNeilBrown path_put(&path);
14299bbf6ecSNeilBrown goto out;
14399bbf6ecSNeilBrown }
1441da177e4SLinus Torvalds
14591c9fa8fSAl Viro exp2 = rqst_exp_get_by_name(rqstp, &path);
1461da177e4SLinus Torvalds if (IS_ERR(exp2)) {
1471da177e4SLinus Torvalds err = PTR_ERR(exp2);
1483b6cee7bSJ. Bruce Fields /*
1493b6cee7bSJ. Bruce Fields * We normally allow NFS clients to continue
1503b6cee7bSJ. Bruce Fields * "underneath" a mountpoint that is not exported.
1513b6cee7bSJ. Bruce Fields * The exception is V4ROOT, where no traversal is ever
1523b6cee7bSJ. Bruce Fields * allowed without an explicit export of the new
1533b6cee7bSJ. Bruce Fields * directory.
1543b6cee7bSJ. Bruce Fields */
1553b6cee7bSJ. Bruce Fields if (err == -ENOENT && !(exp->ex_flags & NFSEXP_V4ROOT))
1563b6cee7bSJ. Bruce Fields err = 0;
15791c9fa8fSAl Viro path_put(&path);
1581da177e4SLinus Torvalds goto out;
1591da177e4SLinus Torvalds }
1603c394ddaSSteve Dickson if (nfsd_v4client(rqstp) ||
1613c394ddaSSteve Dickson (exp->ex_flags & NFSEXP_CROSSMOUNT) || EX_NOHIDE(exp2)) {
1621da177e4SLinus Torvalds /* successfully crossed mount point */
1631644ccc8SAl Viro /*
16491c9fa8fSAl Viro * This is subtle: path.dentry is *not* on path.mnt
16591c9fa8fSAl Viro * at this point. The only reason we are safe is that
16691c9fa8fSAl Viro * original mnt is pinned down by exp, so we should
16791c9fa8fSAl Viro * put path *before* putting exp
1681644ccc8SAl Viro */
16991c9fa8fSAl Viro *dpp = path.dentry;
17091c9fa8fSAl Viro path.dentry = dentry;
1711644ccc8SAl Viro *expp = exp2;
17291c9fa8fSAl Viro exp2 = exp;
1731da177e4SLinus Torvalds }
17491c9fa8fSAl Viro path_put(&path);
17591c9fa8fSAl Viro exp_put(exp2);
1761da177e4SLinus Torvalds out:
1771da177e4SLinus Torvalds return err;
1781da177e4SLinus Torvalds }
1791da177e4SLinus Torvalds
follow_to_parent(struct path * path)180289ede45SJ. Bruce Fields static void follow_to_parent(struct path *path)
181289ede45SJ. Bruce Fields {
182289ede45SJ. Bruce Fields struct dentry *dp;
183289ede45SJ. Bruce Fields
184289ede45SJ. Bruce Fields while (path->dentry == path->mnt->mnt_root && follow_up(path))
185289ede45SJ. Bruce Fields ;
186289ede45SJ. Bruce Fields dp = dget_parent(path->dentry);
187289ede45SJ. Bruce Fields dput(path->dentry);
188289ede45SJ. Bruce Fields path->dentry = dp;
189289ede45SJ. Bruce Fields }
190289ede45SJ. Bruce Fields
nfsd_lookup_parent(struct svc_rqst * rqstp,struct dentry * dparent,struct svc_export ** exp,struct dentry ** dentryp)191289ede45SJ. Bruce Fields static int nfsd_lookup_parent(struct svc_rqst *rqstp, struct dentry *dparent, struct svc_export **exp, struct dentry **dentryp)
192289ede45SJ. Bruce Fields {
193289ede45SJ. Bruce Fields struct svc_export *exp2;
194289ede45SJ. Bruce Fields struct path path = {.mnt = mntget((*exp)->ex_path.mnt),
195289ede45SJ. Bruce Fields .dentry = dget(dparent)};
196289ede45SJ. Bruce Fields
197289ede45SJ. Bruce Fields follow_to_parent(&path);
198289ede45SJ. Bruce Fields
199289ede45SJ. Bruce Fields exp2 = rqst_exp_parent(rqstp, &path);
200289ede45SJ. Bruce Fields if (PTR_ERR(exp2) == -ENOENT) {
201289ede45SJ. Bruce Fields *dentryp = dget(dparent);
202289ede45SJ. Bruce Fields } else if (IS_ERR(exp2)) {
203289ede45SJ. Bruce Fields path_put(&path);
204289ede45SJ. Bruce Fields return PTR_ERR(exp2);
205289ede45SJ. Bruce Fields } else {
206289ede45SJ. Bruce Fields *dentryp = dget(path.dentry);
207289ede45SJ. Bruce Fields exp_put(*exp);
208289ede45SJ. Bruce Fields *exp = exp2;
209289ede45SJ. Bruce Fields }
210289ede45SJ. Bruce Fields path_put(&path);
211289ede45SJ. Bruce Fields return 0;
212289ede45SJ. Bruce Fields }
213289ede45SJ. Bruce Fields
21482ead7feSJ. Bruce Fields /*
21582ead7feSJ. Bruce Fields * For nfsd purposes, we treat V4ROOT exports as though there was an
21682ead7feSJ. Bruce Fields * export at *every* directory.
21799bbf6ecSNeilBrown * We return:
21899bbf6ecSNeilBrown * '1' if this dentry *must* be an export point,
21999bbf6ecSNeilBrown * '2' if it might be, if there is really a mount here, and
22099bbf6ecSNeilBrown * '0' if there is no chance of an export point here.
22182ead7feSJ. Bruce Fields */
nfsd_mountpoint(struct dentry * dentry,struct svc_export * exp)2223227fa41SJ. Bruce Fields int nfsd_mountpoint(struct dentry *dentry, struct svc_export *exp)
22382ead7feSJ. Bruce Fields {
22499bbf6ecSNeilBrown if (!d_inode(dentry))
22599bbf6ecSNeilBrown return 0;
22699bbf6ecSNeilBrown if (exp->ex_flags & NFSEXP_V4ROOT)
22782ead7feSJ. Bruce Fields return 1;
22811fcee02STrond Myklebust if (nfsd4_is_junction(dentry))
22911fcee02STrond Myklebust return 1;
23050f5fdaeSRichard Weinberger if (d_managed(dentry))
23199bbf6ecSNeilBrown /*
23299bbf6ecSNeilBrown * Might only be a mountpoint in a different namespace,
23399bbf6ecSNeilBrown * but we need to check.
23499bbf6ecSNeilBrown */
23599bbf6ecSNeilBrown return 2;
23682ead7feSJ. Bruce Fields return 0;
23782ead7feSJ. Bruce Fields }
23882ead7feSJ. Bruce Fields
2396264d69dSAl Viro __be32
nfsd_lookup_dentry(struct svc_rqst * rqstp,struct svc_fh * fhp,const char * name,unsigned int len,struct svc_export ** exp_ret,struct dentry ** dentry_ret)2406c0a654dSJ. Bruce Fields nfsd_lookup_dentry(struct svc_rqst *rqstp, struct svc_fh *fhp,
2415a022fc8SChuck Lever const char *name, unsigned int len,
2426c0a654dSJ. Bruce Fields struct svc_export **exp_ret, struct dentry **dentry_ret)
2431da177e4SLinus Torvalds {
2441da177e4SLinus Torvalds struct svc_export *exp;
2451da177e4SLinus Torvalds struct dentry *dparent;
2461da177e4SLinus Torvalds struct dentry *dentry;
2476264d69dSAl Viro int host_err;
2481da177e4SLinus Torvalds
2491da177e4SLinus Torvalds dprintk("nfsd: nfsd_lookup(fh %s, %.*s)\n", SVCFH_fmt(fhp), len,name);
2501da177e4SLinus Torvalds
2511da177e4SLinus Torvalds dparent = fhp->fh_dentry;
252bf18f163SKinglong Mee exp = exp_get(fhp->fh_export);
2531da177e4SLinus Torvalds
2541da177e4SLinus Torvalds /* Lookup the name, but don't follow links */
2551da177e4SLinus Torvalds if (isdotent(name, len)) {
2561da177e4SLinus Torvalds if (len==1)
2571da177e4SLinus Torvalds dentry = dget(dparent);
25854775491SJan Blunck else if (dparent != exp->ex_path.dentry)
2591da177e4SLinus Torvalds dentry = dget_parent(dparent);
260fed83811SJ. Bruce Fields else if (!EX_NOHIDE(exp) && !nfsd_v4client(rqstp))
2611da177e4SLinus Torvalds dentry = dget(dparent); /* .. == . just like at / */
2621da177e4SLinus Torvalds else {
2631da177e4SLinus Torvalds /* checking mountpoint crossing is very different when stepping up */
264289ede45SJ. Bruce Fields host_err = nfsd_lookup_parent(rqstp, dparent, &exp, &dentry);
265289ede45SJ. Bruce Fields if (host_err)
2661da177e4SLinus Torvalds goto out_nfserr;
2671da177e4SLinus Torvalds }
2681da177e4SLinus Torvalds } else {
26919d008b4SNeilBrown dentry = lookup_one_len_unlocked(name, dparent, len);
2706264d69dSAl Viro host_err = PTR_ERR(dentry);
2711da177e4SLinus Torvalds if (IS_ERR(dentry))
2721da177e4SLinus Torvalds goto out_nfserr;
27382ead7feSJ. Bruce Fields if (nfsd_mountpoint(dentry, exp)) {
27419d008b4SNeilBrown host_err = nfsd_cross_mnt(rqstp, &dentry, &exp);
27519d008b4SNeilBrown if (host_err) {
2761da177e4SLinus Torvalds dput(dentry);
2771da177e4SLinus Torvalds goto out_nfserr;
2781da177e4SLinus Torvalds }
2791da177e4SLinus Torvalds }
2801da177e4SLinus Torvalds }
2816c0a654dSJ. Bruce Fields *dentry_ret = dentry;
2826c0a654dSJ. Bruce Fields *exp_ret = exp;
2836c0a654dSJ. Bruce Fields return 0;
2846c0a654dSJ. Bruce Fields
2856c0a654dSJ. Bruce Fields out_nfserr:
2866c0a654dSJ. Bruce Fields exp_put(exp);
2876c0a654dSJ. Bruce Fields return nfserrno(host_err);
2886c0a654dSJ. Bruce Fields }
2896c0a654dSJ. Bruce Fields
29019d008b4SNeilBrown /**
29119d008b4SNeilBrown * nfsd_lookup - look up a single path component for nfsd
29219d008b4SNeilBrown *
29319d008b4SNeilBrown * @rqstp: the request context
29419d008b4SNeilBrown * @fhp: the file handle of the directory
29519d008b4SNeilBrown * @name: the component name, or %NULL to look up parent
29619d008b4SNeilBrown * @len: length of name to examine
29719d008b4SNeilBrown * @resfh: pointer to pre-initialised filehandle to hold result.
29819d008b4SNeilBrown *
2996c0a654dSJ. Bruce Fields * Look up one component of a pathname.
3006c0a654dSJ. Bruce Fields * N.B. After this call _both_ fhp and resfh need an fh_put
3016c0a654dSJ. Bruce Fields *
3026c0a654dSJ. Bruce Fields * If the lookup would cross a mountpoint, and the mounted filesystem
3036c0a654dSJ. Bruce Fields * is exported to the client with NFSEXP_NOHIDE, then the lookup is
3046c0a654dSJ. Bruce Fields * accepted as it stands and the mounted directory is
3056c0a654dSJ. Bruce Fields * returned. Otherwise the covered directory is returned.
3066c0a654dSJ. Bruce Fields * NOTE: this mountpoint crossing is not supported properly by all
3076c0a654dSJ. Bruce Fields * clients and is explicitly disallowed for NFSv3
30819d008b4SNeilBrown *
3096c0a654dSJ. Bruce Fields */
3106c0a654dSJ. Bruce Fields __be32
nfsd_lookup(struct svc_rqst * rqstp,struct svc_fh * fhp,const char * name,unsigned int len,struct svc_fh * resfh)3116c0a654dSJ. Bruce Fields nfsd_lookup(struct svc_rqst *rqstp, struct svc_fh *fhp, const char *name,
3125a022fc8SChuck Lever unsigned int len, struct svc_fh *resfh)
3136c0a654dSJ. Bruce Fields {
3146c0a654dSJ. Bruce Fields struct svc_export *exp;
3156c0a654dSJ. Bruce Fields struct dentry *dentry;
3166c0a654dSJ. Bruce Fields __be32 err;
3176c0a654dSJ. Bruce Fields
31829a78a3eSJ. Bruce Fields err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_EXEC);
31929a78a3eSJ. Bruce Fields if (err)
32029a78a3eSJ. Bruce Fields return err;
3216c0a654dSJ. Bruce Fields err = nfsd_lookup_dentry(rqstp, fhp, name, len, &exp, &dentry);
3226c0a654dSJ. Bruce Fields if (err)
3236c0a654dSJ. Bruce Fields return err;
32432c1eb0cSAndy Adamson err = check_nfsd_access(exp, rqstp);
32532c1eb0cSAndy Adamson if (err)
32632c1eb0cSAndy Adamson goto out;
3271da177e4SLinus Torvalds /*
3281da177e4SLinus Torvalds * Note: we compose the file handle now, but as the
3291da177e4SLinus Torvalds * dentry may be negative, it may need to be updated.
3301da177e4SLinus Torvalds */
3311da177e4SLinus Torvalds err = fh_compose(resfh, exp, dentry, fhp);
3322b0143b5SDavid Howells if (!err && d_really_is_negative(dentry))
3331da177e4SLinus Torvalds err = nfserr_noent;
33432c1eb0cSAndy Adamson out:
3351da177e4SLinus Torvalds dput(dentry);
3361da177e4SLinus Torvalds exp_put(exp);
3371da177e4SLinus Torvalds return err;
3381da177e4SLinus Torvalds }
3391da177e4SLinus Torvalds
340f501912aSBen Myers /*
341f501912aSBen Myers * Commit metadata changes to stable storage.
342f501912aSBen Myers */
343f501912aSBen Myers static int
commit_inode_metadata(struct inode * inode)34457f64034STrond Myklebust commit_inode_metadata(struct inode *inode)
345f501912aSBen Myers {
346f501912aSBen Myers const struct export_operations *export_ops = inode->i_sb->s_export_op;
347f501912aSBen Myers
348c3765016SChristoph Hellwig if (export_ops->commit_metadata)
349c3765016SChristoph Hellwig return export_ops->commit_metadata(inode);
350c3765016SChristoph Hellwig return sync_inode_metadata(inode, 1);
351f501912aSBen Myers }
3526c0a654dSJ. Bruce Fields
35357f64034STrond Myklebust static int
commit_metadata(struct svc_fh * fhp)35457f64034STrond Myklebust commit_metadata(struct svc_fh *fhp)
35557f64034STrond Myklebust {
35657f64034STrond Myklebust struct inode *inode = d_inode(fhp->fh_dentry);
35757f64034STrond Myklebust
35857f64034STrond Myklebust if (!EX_ISSYNC(fhp->fh_export))
35957f64034STrond Myklebust return 0;
36057f64034STrond Myklebust return commit_inode_metadata(inode);
36157f64034STrond Myklebust }
36257f64034STrond Myklebust
3631da177e4SLinus Torvalds /*
364818e5a22SChristoph Hellwig * Go over the attributes and take care of the small differences between
365818e5a22SChristoph Hellwig * NFS semantics and what Linux expects.
366818e5a22SChristoph Hellwig */
367818e5a22SChristoph Hellwig static void
nfsd_sanitize_attrs(struct inode * inode,struct iattr * iap)368818e5a22SChristoph Hellwig nfsd_sanitize_attrs(struct inode *inode, struct iattr *iap)
369818e5a22SChristoph Hellwig {
37000801cd9SNeilBrown /* Ignore mode updates on symlinks */
37100801cd9SNeilBrown if (S_ISLNK(inode->i_mode))
37200801cd9SNeilBrown iap->ia_valid &= ~ATTR_MODE;
37300801cd9SNeilBrown
374818e5a22SChristoph Hellwig /* sanitize the mode change */
375818e5a22SChristoph Hellwig if (iap->ia_valid & ATTR_MODE) {
376818e5a22SChristoph Hellwig iap->ia_mode &= S_IALLUGO;
377818e5a22SChristoph Hellwig iap->ia_mode |= (inode->i_mode & ~S_IALLUGO);
378818e5a22SChristoph Hellwig }
379818e5a22SChristoph Hellwig
380818e5a22SChristoph Hellwig /* Revoke setuid/setgid on chown */
381818e5a22SChristoph Hellwig if (!S_ISDIR(inode->i_mode) &&
382c4fa6d7cSStanislav Kholmanskikh ((iap->ia_valid & ATTR_UID) || (iap->ia_valid & ATTR_GID))) {
383818e5a22SChristoph Hellwig iap->ia_valid |= ATTR_KILL_PRIV;
384818e5a22SChristoph Hellwig if (iap->ia_valid & ATTR_MODE) {
385818e5a22SChristoph Hellwig /* we're setting mode too, just clear the s*id bits */
386818e5a22SChristoph Hellwig iap->ia_mode &= ~S_ISUID;
387818e5a22SChristoph Hellwig if (iap->ia_mode & S_IXGRP)
388818e5a22SChristoph Hellwig iap->ia_mode &= ~S_ISGID;
389818e5a22SChristoph Hellwig } else {
390818e5a22SChristoph Hellwig /* set ATTR_KILL_* bits and let VFS handle it */
3912d8ae8c4SChristian Brauner iap->ia_valid |= ATTR_KILL_SUID;
3922d8ae8c4SChristian Brauner iap->ia_valid |=
3932d8ae8c4SChristian Brauner setattr_should_drop_sgid(&nop_mnt_idmap, inode);
394818e5a22SChristoph Hellwig }
395818e5a22SChristoph Hellwig }
396818e5a22SChristoph Hellwig }
397818e5a22SChristoph Hellwig
3980839ffb8SJ. Bruce Fields static __be32
nfsd_get_write_access(struct svc_rqst * rqstp,struct svc_fh * fhp,struct iattr * iap)3990839ffb8SJ. Bruce Fields nfsd_get_write_access(struct svc_rqst *rqstp, struct svc_fh *fhp,
4000839ffb8SJ. Bruce Fields struct iattr *iap)
4010839ffb8SJ. Bruce Fields {
4020839ffb8SJ. Bruce Fields struct inode *inode = d_inode(fhp->fh_dentry);
4030839ffb8SJ. Bruce Fields
4040839ffb8SJ. Bruce Fields if (iap->ia_size < inode->i_size) {
4050839ffb8SJ. Bruce Fields __be32 err;
4060839ffb8SJ. Bruce Fields
4070839ffb8SJ. Bruce Fields err = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry,
4080839ffb8SJ. Bruce Fields NFSD_MAY_TRUNC | NFSD_MAY_OWNER_OVERRIDE);
4090839ffb8SJ. Bruce Fields if (err)
4100839ffb8SJ. Bruce Fields return err;
4110839ffb8SJ. Bruce Fields }
412f7e33bdbSJeff Layton return nfserrno(get_write_access(inode));
4130839ffb8SJ. Bruce Fields }
4140839ffb8SJ. Bruce Fields
__nfsd_setattr(struct dentry * dentry,struct iattr * iap)415c0aa1913SChuck Lever static int __nfsd_setattr(struct dentry *dentry, struct iattr *iap)
416c0aa1913SChuck Lever {
417c0aa1913SChuck Lever int host_err;
418c0aa1913SChuck Lever
419c0aa1913SChuck Lever if (iap->ia_valid & ATTR_SIZE) {
420818e5a22SChristoph Hellwig /*
421c0aa1913SChuck Lever * RFC5661, Section 18.30.4:
422c0aa1913SChuck Lever * Changing the size of a file with SETATTR indirectly
423c0aa1913SChuck Lever * changes the time_modify and change attributes.
424c0aa1913SChuck Lever *
425c0aa1913SChuck Lever * (and similar for the older RFCs)
426c0aa1913SChuck Lever */
427c0aa1913SChuck Lever struct iattr size_attr = {
428c0aa1913SChuck Lever .ia_valid = ATTR_SIZE | ATTR_CTIME | ATTR_MTIME,
429c0aa1913SChuck Lever .ia_size = iap->ia_size,
430c0aa1913SChuck Lever };
431c0aa1913SChuck Lever
432c0aa1913SChuck Lever if (iap->ia_size < 0)
433c0aa1913SChuck Lever return -EFBIG;
434c0aa1913SChuck Lever
435abf08576SChristian Brauner host_err = notify_change(&nop_mnt_idmap, dentry, &size_attr, NULL);
436c0aa1913SChuck Lever if (host_err)
437c0aa1913SChuck Lever return host_err;
438c0aa1913SChuck Lever iap->ia_valid &= ~ATTR_SIZE;
439c0aa1913SChuck Lever
440c0aa1913SChuck Lever /*
441c0aa1913SChuck Lever * Avoid the additional setattr call below if the only other
442c0aa1913SChuck Lever * attribute that the client sends is the mtime, as we update
443c0aa1913SChuck Lever * it as part of the size change above.
444c0aa1913SChuck Lever */
445c0aa1913SChuck Lever if ((iap->ia_valid & ~ATTR_MTIME) == 0)
446c0aa1913SChuck Lever return 0;
447c0aa1913SChuck Lever }
448c0aa1913SChuck Lever
449c0aa1913SChuck Lever if (!iap->ia_valid)
450c0aa1913SChuck Lever return 0;
451c0aa1913SChuck Lever
452c0aa1913SChuck Lever iap->ia_valid |= ATTR_CTIME;
453abf08576SChristian Brauner return notify_change(&nop_mnt_idmap, dentry, iap, NULL);
454c0aa1913SChuck Lever }
455c0aa1913SChuck Lever
456c0aa1913SChuck Lever /**
457c0aa1913SChuck Lever * nfsd_setattr - Set various file attributes.
458c0aa1913SChuck Lever * @rqstp: controlling RPC transaction
459c0aa1913SChuck Lever * @fhp: filehandle of target
460c0aa1913SChuck Lever * @attr: attributes to set
461c0aa1913SChuck Lever * @check_guard: set to 1 if guardtime is a valid timestamp
462c0aa1913SChuck Lever * @guardtime: do not act if ctime.tv_sec does not match this timestamp
463c0aa1913SChuck Lever *
464c0aa1913SChuck Lever * This call may adjust the contents of @attr (in particular, this
465c0aa1913SChuck Lever * call may change the bits in the na_iattr.ia_valid field).
466c0aa1913SChuck Lever *
467c0aa1913SChuck Lever * Returns nfs_ok on success, otherwise an NFS status code is
468c0aa1913SChuck Lever * returned. Caller must release @fhp by calling fh_put in either
469c0aa1913SChuck Lever * case.
4701da177e4SLinus Torvalds */
4716264d69dSAl Viro __be32
nfsd_setattr(struct svc_rqst * rqstp,struct svc_fh * fhp,struct nfsd_attrs * attr,int check_guard,time64_t guardtime)4727fe2a71dSNeilBrown nfsd_setattr(struct svc_rqst *rqstp, struct svc_fh *fhp,
4737fe2a71dSNeilBrown struct nfsd_attrs *attr,
4742a1aa489SArnd Bergmann int check_guard, time64_t guardtime)
4751da177e4SLinus Torvalds {
4761da177e4SLinus Torvalds struct dentry *dentry;
4771da177e4SLinus Torvalds struct inode *inode;
4787fe2a71dSNeilBrown struct iattr *iap = attr->na_iattr;
4798837abcaSMiklos Szeredi int accmode = NFSD_MAY_SATTR;
480175a4eb7SAl Viro umode_t ftype = 0;
4816264d69dSAl Viro __be32 err;
482c0aa1913SChuck Lever int host_err;
4839f67f189SJ. Bruce Fields bool get_write_count;
484758e99feSChristoph Hellwig bool size_change = (iap->ia_valid & ATTR_SIZE);
48534b91ddaSChuck Lever int retries;
4861da177e4SLinus Torvalds
487255fbca6Szhengbin if (iap->ia_valid & ATTR_SIZE) {
4888837abcaSMiklos Szeredi accmode |= NFSD_MAY_WRITE|NFSD_MAY_OWNER_OVERRIDE;
4891da177e4SLinus Torvalds ftype = S_IFREG;
490255fbca6Szhengbin }
491255fbca6Szhengbin
492255fbca6Szhengbin /*
493255fbca6Szhengbin * If utimes(2) and friends are called with times not NULL, we should
494255fbca6Szhengbin * not set NFSD_MAY_WRITE bit. Otherwise fh_verify->nfsd_permission
495e977cc83SGeert Uytterhoeven * will return EACCES, when the caller's effective UID does not match
496255fbca6Szhengbin * the owner of the file, and the caller is not privileged. In this
497255fbca6Szhengbin * situation, we should return EPERM(notify_change will return this).
498255fbca6Szhengbin */
499255fbca6Szhengbin if (iap->ia_valid & (ATTR_ATIME | ATTR_MTIME)) {
500255fbca6Szhengbin accmode |= NFSD_MAY_OWNER_OVERRIDE;
501255fbca6Szhengbin if (!(iap->ia_valid & (ATTR_ATIME_SET | ATTR_MTIME_SET)))
502255fbca6Szhengbin accmode |= NFSD_MAY_WRITE;
503255fbca6Szhengbin }
5041da177e4SLinus Torvalds
5059f67f189SJ. Bruce Fields /* Callers that do fh_verify should do the fh_want_write: */
5069f67f189SJ. Bruce Fields get_write_count = !fhp->fh_dentry;
5079f67f189SJ. Bruce Fields
5081da177e4SLinus Torvalds /* Get inode */
5091da177e4SLinus Torvalds err = fh_verify(rqstp, fhp, ftype, accmode);
51015b7a1b8SNeilBrown if (err)
511758e99feSChristoph Hellwig return err;
5129f67f189SJ. Bruce Fields if (get_write_count) {
5139f67f189SJ. Bruce Fields host_err = fh_want_write(fhp);
5149f67f189SJ. Bruce Fields if (host_err)
515758e99feSChristoph Hellwig goto out;
5169f67f189SJ. Bruce Fields }
5171da177e4SLinus Torvalds
5181da177e4SLinus Torvalds dentry = fhp->fh_dentry;
5192b0143b5SDavid Howells inode = d_inode(dentry);
5201da177e4SLinus Torvalds
521818e5a22SChristoph Hellwig nfsd_sanitize_attrs(inode, iap);
5221da177e4SLinus Torvalds
52338d721b1SJeff Layton if (check_guard && guardtime != inode_get_ctime(inode).tv_sec)
524758e99feSChristoph Hellwig return nfserr_notsync;
525758e99feSChristoph Hellwig
526f0c63124SChristoph Hellwig /*
52741f53350SChristoph Hellwig * The size case is special, it changes the file in addition to the
528783112f7SChristoph Hellwig * attributes, and file systems don't expect it to be mixed with
529783112f7SChristoph Hellwig * "random" attribute changes. We thus split out the size change
530783112f7SChristoph Hellwig * into a separate call to ->setattr, and do the rest as a separate
531783112f7SChristoph Hellwig * setattr call.
532f0c63124SChristoph Hellwig */
533758e99feSChristoph Hellwig if (size_change) {
5340839ffb8SJ. Bruce Fields err = nfsd_get_write_access(rqstp, fhp, iap);
5350839ffb8SJ. Bruce Fields if (err)
536758e99feSChristoph Hellwig return err;
537783112f7SChristoph Hellwig }
53841f53350SChristoph Hellwig
539bb4d53d6SNeilBrown inode_lock(inode);
54034b91ddaSChuck Lever for (retries = 1;;) {
541d53d7008SJeff Layton struct iattr attrs;
542d53d7008SJeff Layton
543d53d7008SJeff Layton /*
544d53d7008SJeff Layton * notify_change() can alter its iattr argument, making
545d53d7008SJeff Layton * @iap unsuitable for submission multiple times. Make a
546d53d7008SJeff Layton * copy for every loop iteration.
547d53d7008SJeff Layton */
548d53d7008SJeff Layton attrs = *iap;
549d53d7008SJeff Layton host_err = __nfsd_setattr(dentry, &attrs);
55034b91ddaSChuck Lever if (host_err != -EAGAIN || !retries--)
55134b91ddaSChuck Lever break;
55234b91ddaSChuck Lever if (!nfsd_wait_for_delegreturn(rqstp, inode))
55334b91ddaSChuck Lever break;
55434b91ddaSChuck Lever }
555d6a97d3fSNeilBrown if (attr->na_seclabel && attr->na_seclabel->len)
556d6a97d3fSNeilBrown attr->na_labelerr = security_inode_setsecctx(dentry,
557d6a97d3fSNeilBrown attr->na_seclabel->data, attr->na_seclabel->len);
558c0cbe707SNeilBrown if (IS_ENABLED(CONFIG_FS_POSIX_ACL) && attr->na_pacl)
55913e83a49SChristian Brauner attr->na_aclerr = set_posix_acl(&nop_mnt_idmap,
560138060baSChristian Brauner dentry, ACL_TYPE_ACCESS,
561c0cbe707SNeilBrown attr->na_pacl);
562c0cbe707SNeilBrown if (IS_ENABLED(CONFIG_FS_POSIX_ACL) &&
563c0cbe707SNeilBrown !attr->na_aclerr && attr->na_dpacl && S_ISDIR(inode->i_mode))
56413e83a49SChristian Brauner attr->na_aclerr = set_posix_acl(&nop_mnt_idmap,
565138060baSChristian Brauner dentry, ACL_TYPE_DEFAULT,
566c0cbe707SNeilBrown attr->na_dpacl);
567bb4d53d6SNeilBrown inode_unlock(inode);
5680839ffb8SJ. Bruce Fields if (size_change)
5690839ffb8SJ. Bruce Fields put_write_access(inode);
5700839ffb8SJ. Bruce Fields out:
571758e99feSChristoph Hellwig if (!host_err)
572758e99feSChristoph Hellwig host_err = commit_metadata(fhp);
573758e99feSChristoph Hellwig return nfserrno(host_err);
5741da177e4SLinus Torvalds }
5751da177e4SLinus Torvalds
5765be196e5SChristoph Hellwig #if defined(CONFIG_NFSD_V4)
5779b4146e8SChuck Lever /*
5789b4146e8SChuck Lever * NFS junction information is stored in an extended attribute.
5799b4146e8SChuck Lever */
5809b4146e8SChuck Lever #define NFSD_JUNCTION_XATTR_NAME XATTR_TRUSTED_PREFIX "junction.nfs"
5819b4146e8SChuck Lever
5829b4146e8SChuck Lever /**
5839b4146e8SChuck Lever * nfsd4_is_junction - Test if an object could be an NFS junction
5849b4146e8SChuck Lever *
5859b4146e8SChuck Lever * @dentry: object to test
5869b4146e8SChuck Lever *
5879b4146e8SChuck Lever * Returns 1 if "dentry" appears to contain NFS junction information.
5889b4146e8SChuck Lever * Otherwise 0 is returned.
5899b4146e8SChuck Lever */
nfsd4_is_junction(struct dentry * dentry)59011fcee02STrond Myklebust int nfsd4_is_junction(struct dentry *dentry)
59111fcee02STrond Myklebust {
5922b0143b5SDavid Howells struct inode *inode = d_inode(dentry);
59311fcee02STrond Myklebust
59411fcee02STrond Myklebust if (inode == NULL)
59511fcee02STrond Myklebust return 0;
59611fcee02STrond Myklebust if (inode->i_mode & S_IXUGO)
59711fcee02STrond Myklebust return 0;
59811fcee02STrond Myklebust if (!(inode->i_mode & S_ISVTX))
59911fcee02STrond Myklebust return 0;
6004609e1f1SChristian Brauner if (vfs_getxattr(&nop_mnt_idmap, dentry, NFSD_JUNCTION_XATTR_NAME,
601c7c7a1a1STycho Andersen NULL, 0) <= 0)
60211fcee02STrond Myklebust return 0;
60311fcee02STrond Myklebust return 1;
60411fcee02STrond Myklebust }
60518032ca0SDavid Quigley
nfsd4_get_cstate(struct svc_rqst * rqstp)606a2f4c3faSTrond Myklebust static struct nfsd4_compound_state *nfsd4_get_cstate(struct svc_rqst *rqstp)
607a2f4c3faSTrond Myklebust {
608a2f4c3faSTrond Myklebust return &((struct nfsd4_compoundres *)rqstp->rq_resp)->cstate;
609a2f4c3faSTrond Myklebust }
610a2f4c3faSTrond Myklebust
nfsd4_clone_file_range(struct svc_rqst * rqstp,struct nfsd_file * nf_src,u64 src_pos,struct nfsd_file * nf_dst,u64 dst_pos,u64 count,bool sync)611a2f4c3faSTrond Myklebust __be32 nfsd4_clone_file_range(struct svc_rqst *rqstp,
612a2f4c3faSTrond Myklebust struct nfsd_file *nf_src, u64 src_pos,
613a2f4c3faSTrond Myklebust struct nfsd_file *nf_dst, u64 dst_pos,
614a2f4c3faSTrond Myklebust u64 count, bool sync)
615ffa0160aSChristoph Hellwig {
616b66ae6ddSTrond Myklebust struct file *src = nf_src->nf_file;
617b66ae6ddSTrond Myklebust struct file *dst = nf_dst->nf_file;
618555dbf1aSTrond Myklebust errseq_t since;
61942ec3d4cSDarrick J. Wong loff_t cloned;
6201b28d756STrond Myklebust __be32 ret = 0;
62142ec3d4cSDarrick J. Wong
622555dbf1aSTrond Myklebust since = READ_ONCE(dst->f_wb_err);
623452ce659SDarrick J. Wong cloned = vfs_clone_file_range(src, src_pos, dst, dst_pos, count, 0);
6241b28d756STrond Myklebust if (cloned < 0) {
6251b28d756STrond Myklebust ret = nfserrno(cloned);
6261b28d756STrond Myklebust goto out_err;
6271b28d756STrond Myklebust }
6281b28d756STrond Myklebust if (count && cloned != count) {
6291b28d756STrond Myklebust ret = nfserrno(-EINVAL);
6301b28d756STrond Myklebust goto out_err;
6311b28d756STrond Myklebust }
632a25e3726STrond Myklebust if (sync) {
633a25e3726STrond Myklebust loff_t dst_end = count ? dst_pos + count - 1 : LLONG_MAX;
634a25e3726STrond Myklebust int status = vfs_fsync_range(dst, dst_pos, dst_end, 0);
63557f64034STrond Myklebust
63657f64034STrond Myklebust if (!status)
637555dbf1aSTrond Myklebust status = filemap_check_wb_err(dst->f_mapping, since);
638555dbf1aSTrond Myklebust if (!status)
63957f64034STrond Myklebust status = commit_inode_metadata(file_inode(src));
6401b28d756STrond Myklebust if (status < 0) {
64175acacb6SChuck Lever struct nfsd_net *nn = net_generic(nf_dst->nf_net,
64275acacb6SChuck Lever nfsd_net_id);
64375acacb6SChuck Lever
644a2f4c3faSTrond Myklebust trace_nfsd_clone_file_range_err(rqstp,
645a2f4c3faSTrond Myklebust &nfsd4_get_cstate(rqstp)->save_fh,
646a2f4c3faSTrond Myklebust src_pos,
647a2f4c3faSTrond Myklebust &nfsd4_get_cstate(rqstp)->current_fh,
648a2f4c3faSTrond Myklebust dst_pos,
649a2f4c3faSTrond Myklebust count, status);
65075acacb6SChuck Lever nfsd_reset_write_verifier(nn);
65175acacb6SChuck Lever trace_nfsd_writeverf_reset(nn, rqstp, status);
6521b28d756STrond Myklebust ret = nfserrno(status);
653a25e3726STrond Myklebust }
6541b28d756STrond Myklebust }
6551b28d756STrond Myklebust out_err:
6561b28d756STrond Myklebust return ret;
657ffa0160aSChristoph Hellwig }
658ffa0160aSChristoph Hellwig
nfsd_copy_file_range(struct file * src,u64 src_pos,struct file * dst,u64 dst_pos,u64 count)65929ae7f9dSAnna Schumaker ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst,
66029ae7f9dSAnna Schumaker u64 dst_pos, u64 count)
66129ae7f9dSAnna Schumaker {
662868f9f2fSAmir Goldstein ssize_t ret;
66329ae7f9dSAnna Schumaker
66429ae7f9dSAnna Schumaker /*
66529ae7f9dSAnna Schumaker * Limit copy to 4MB to prevent indefinitely blocking an nfsd
66629ae7f9dSAnna Schumaker * thread and client rpc slot. The choice of 4MB is somewhat
66729ae7f9dSAnna Schumaker * arbitrary. We might instead base this on r/wsize, or make it
66829ae7f9dSAnna Schumaker * tunable, or use a time instead of a byte limit, or implement
66929ae7f9dSAnna Schumaker * asynchronous copy. In theory a client could also recognize a
67029ae7f9dSAnna Schumaker * limit like this and pipeline multiple COPY requests.
67129ae7f9dSAnna Schumaker */
67229ae7f9dSAnna Schumaker count = min_t(u64, count, 1 << 22);
673868f9f2fSAmir Goldstein ret = vfs_copy_file_range(src, src_pos, dst, dst_pos, count, 0);
674868f9f2fSAmir Goldstein
675868f9f2fSAmir Goldstein if (ret == -EOPNOTSUPP || ret == -EXDEV)
67610bc8e4aSAmir Goldstein ret = vfs_copy_file_range(src, src_pos, dst, dst_pos, count,
67710bc8e4aSAmir Goldstein COPY_FILE_SPLICE);
678868f9f2fSAmir Goldstein return ret;
67929ae7f9dSAnna Schumaker }
68029ae7f9dSAnna Schumaker
nfsd4_vfs_fallocate(struct svc_rqst * rqstp,struct svc_fh * fhp,struct file * file,loff_t offset,loff_t len,int flags)68195d871f0SAnna Schumaker __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp,
68295d871f0SAnna Schumaker struct file *file, loff_t offset, loff_t len,
68395d871f0SAnna Schumaker int flags)
68495d871f0SAnna Schumaker {
68595d871f0SAnna Schumaker int error;
68695d871f0SAnna Schumaker
68795d871f0SAnna Schumaker if (!S_ISREG(file_inode(file)->i_mode))
68895d871f0SAnna Schumaker return nfserr_inval;
68995d871f0SAnna Schumaker
69095d871f0SAnna Schumaker error = vfs_fallocate(file, flags, offset, len);
69195d871f0SAnna Schumaker if (!error)
69295d871f0SAnna Schumaker error = commit_metadata(fhp);
69395d871f0SAnna Schumaker
69495d871f0SAnna Schumaker return nfserrno(error);
69595d871f0SAnna Schumaker }
6966a85d6c7SJ. Bruce Fields #endif /* defined(CONFIG_NFSD_V4) */
6971da177e4SLinus Torvalds
6981da177e4SLinus Torvalds /*
6991da177e4SLinus Torvalds * Check server access rights to a file system object
7001da177e4SLinus Torvalds */
7011da177e4SLinus Torvalds struct accessmap {
7021da177e4SLinus Torvalds u32 access;
7031da177e4SLinus Torvalds int how;
7041da177e4SLinus Torvalds };
7051da177e4SLinus Torvalds static struct accessmap nfs3_regaccess[] = {
7068837abcaSMiklos Szeredi { NFS3_ACCESS_READ, NFSD_MAY_READ },
7078837abcaSMiklos Szeredi { NFS3_ACCESS_EXECUTE, NFSD_MAY_EXEC },
7088837abcaSMiklos Szeredi { NFS3_ACCESS_MODIFY, NFSD_MAY_WRITE|NFSD_MAY_TRUNC },
7098837abcaSMiklos Szeredi { NFS3_ACCESS_EXTEND, NFSD_MAY_WRITE },
7101da177e4SLinus Torvalds
711c11d7fd1SFrank van der Linden #ifdef CONFIG_NFSD_V4
712c11d7fd1SFrank van der Linden { NFS4_ACCESS_XAREAD, NFSD_MAY_READ },
713c11d7fd1SFrank van der Linden { NFS4_ACCESS_XAWRITE, NFSD_MAY_WRITE },
714c11d7fd1SFrank van der Linden { NFS4_ACCESS_XALIST, NFSD_MAY_READ },
715c11d7fd1SFrank van der Linden #endif
716c11d7fd1SFrank van der Linden
7171da177e4SLinus Torvalds { 0, 0 }
7181da177e4SLinus Torvalds };
7191da177e4SLinus Torvalds
7201da177e4SLinus Torvalds static struct accessmap nfs3_diraccess[] = {
7218837abcaSMiklos Szeredi { NFS3_ACCESS_READ, NFSD_MAY_READ },
7228837abcaSMiklos Szeredi { NFS3_ACCESS_LOOKUP, NFSD_MAY_EXEC },
7238837abcaSMiklos Szeredi { NFS3_ACCESS_MODIFY, NFSD_MAY_EXEC|NFSD_MAY_WRITE|NFSD_MAY_TRUNC},
7248837abcaSMiklos Szeredi { NFS3_ACCESS_EXTEND, NFSD_MAY_EXEC|NFSD_MAY_WRITE },
7258837abcaSMiklos Szeredi { NFS3_ACCESS_DELETE, NFSD_MAY_REMOVE },
7261da177e4SLinus Torvalds
727c11d7fd1SFrank van der Linden #ifdef CONFIG_NFSD_V4
728c11d7fd1SFrank van der Linden { NFS4_ACCESS_XAREAD, NFSD_MAY_READ },
729c11d7fd1SFrank van der Linden { NFS4_ACCESS_XAWRITE, NFSD_MAY_WRITE },
730c11d7fd1SFrank van der Linden { NFS4_ACCESS_XALIST, NFSD_MAY_READ },
731c11d7fd1SFrank van der Linden #endif
732c11d7fd1SFrank van der Linden
7331da177e4SLinus Torvalds { 0, 0 }
7341da177e4SLinus Torvalds };
7351da177e4SLinus Torvalds
7361da177e4SLinus Torvalds static struct accessmap nfs3_anyaccess[] = {
7371da177e4SLinus Torvalds /* Some clients - Solaris 2.6 at least, make an access call
7381da177e4SLinus Torvalds * to the server to check for access for things like /dev/null
7391da177e4SLinus Torvalds * (which really, the server doesn't care about). So
7401da177e4SLinus Torvalds * We provide simple access checking for them, looking
7411da177e4SLinus Torvalds * mainly at mode bits, and we make sure to ignore read-only
7421da177e4SLinus Torvalds * filesystem checks
7431da177e4SLinus Torvalds */
7448837abcaSMiklos Szeredi { NFS3_ACCESS_READ, NFSD_MAY_READ },
7458837abcaSMiklos Szeredi { NFS3_ACCESS_EXECUTE, NFSD_MAY_EXEC },
7468837abcaSMiklos Szeredi { NFS3_ACCESS_MODIFY, NFSD_MAY_WRITE|NFSD_MAY_LOCAL_ACCESS },
7478837abcaSMiklos Szeredi { NFS3_ACCESS_EXTEND, NFSD_MAY_WRITE|NFSD_MAY_LOCAL_ACCESS },
7481da177e4SLinus Torvalds
7491da177e4SLinus Torvalds { 0, 0 }
7501da177e4SLinus Torvalds };
7511da177e4SLinus Torvalds
7526264d69dSAl Viro __be32
nfsd_access(struct svc_rqst * rqstp,struct svc_fh * fhp,u32 * access,u32 * supported)7531da177e4SLinus Torvalds nfsd_access(struct svc_rqst *rqstp, struct svc_fh *fhp, u32 *access, u32 *supported)
7541da177e4SLinus Torvalds {
7551da177e4SLinus Torvalds struct accessmap *map;
7561da177e4SLinus Torvalds struct svc_export *export;
7571da177e4SLinus Torvalds struct dentry *dentry;
7581da177e4SLinus Torvalds u32 query, result = 0, sresult = 0;
7596264d69dSAl Viro __be32 error;
7601da177e4SLinus Torvalds
7618837abcaSMiklos Szeredi error = fh_verify(rqstp, fhp, 0, NFSD_MAY_NOP);
7621da177e4SLinus Torvalds if (error)
7631da177e4SLinus Torvalds goto out;
7641da177e4SLinus Torvalds
7651da177e4SLinus Torvalds export = fhp->fh_export;
7661da177e4SLinus Torvalds dentry = fhp->fh_dentry;
7671da177e4SLinus Torvalds
768e36cb0b8SDavid Howells if (d_is_reg(dentry))
7691da177e4SLinus Torvalds map = nfs3_regaccess;
770e36cb0b8SDavid Howells else if (d_is_dir(dentry))
7711da177e4SLinus Torvalds map = nfs3_diraccess;
7721da177e4SLinus Torvalds else
7731da177e4SLinus Torvalds map = nfs3_anyaccess;
7741da177e4SLinus Torvalds
7751da177e4SLinus Torvalds
7761da177e4SLinus Torvalds query = *access;
7771da177e4SLinus Torvalds for (; map->access; map++) {
7781da177e4SLinus Torvalds if (map->access & query) {
7796264d69dSAl Viro __be32 err2;
7801da177e4SLinus Torvalds
7811da177e4SLinus Torvalds sresult |= map->access;
7821da177e4SLinus Torvalds
7830ec757dfSJ. Bruce Fields err2 = nfsd_permission(rqstp, export, dentry, map->how);
7841da177e4SLinus Torvalds switch (err2) {
7851da177e4SLinus Torvalds case nfs_ok:
7861da177e4SLinus Torvalds result |= map->access;
7871da177e4SLinus Torvalds break;
7881da177e4SLinus Torvalds
7891da177e4SLinus Torvalds /* the following error codes just mean the access was not allowed,
7901da177e4SLinus Torvalds * rather than an error occurred */
7911da177e4SLinus Torvalds case nfserr_rofs:
7921da177e4SLinus Torvalds case nfserr_acces:
7931da177e4SLinus Torvalds case nfserr_perm:
7941da177e4SLinus Torvalds /* simply don't "or" in the access bit. */
7951da177e4SLinus Torvalds break;
7961da177e4SLinus Torvalds default:
7971da177e4SLinus Torvalds error = err2;
7981da177e4SLinus Torvalds goto out;
7991da177e4SLinus Torvalds }
8001da177e4SLinus Torvalds }
8011da177e4SLinus Torvalds }
8021da177e4SLinus Torvalds *access = result;
8031da177e4SLinus Torvalds if (supported)
8041da177e4SLinus Torvalds *supported = sresult;
8051da177e4SLinus Torvalds
8061da177e4SLinus Torvalds out:
8071da177e4SLinus Torvalds return error;
8081da177e4SLinus Torvalds }
8091da177e4SLinus Torvalds
nfsd_open_break_lease(struct inode * inode,int access)81065294c1fSJeff Layton int nfsd_open_break_lease(struct inode *inode, int access)
811105f4622SJ. Bruce Fields {
812105f4622SJ. Bruce Fields unsigned int mode;
8131da177e4SLinus Torvalds
814105f4622SJ. Bruce Fields if (access & NFSD_MAY_NOT_BREAK_LEASE)
815105f4622SJ. Bruce Fields return 0;
816105f4622SJ. Bruce Fields mode = (access & NFSD_MAY_WRITE) ? O_WRONLY : O_RDONLY;
817105f4622SJ. Bruce Fields return break_lease(inode, mode | O_NONBLOCK);
818105f4622SJ. Bruce Fields }
8191da177e4SLinus Torvalds
8201da177e4SLinus Torvalds /*
8211da177e4SLinus Torvalds * Open an existing file or directory.
822999448a8SBernd Schubert * The may_flags argument indicates the type of open (read/write/lock)
823999448a8SBernd Schubert * and additional flags.
8241da177e4SLinus Torvalds * N.B. After this call fhp needs an fh_put
8251da177e4SLinus Torvalds */
82683f8fc2cSTrond Myklebust static int
__nfsd_open(struct svc_rqst * rqstp,struct svc_fh * fhp,umode_t type,int may_flags,struct file ** filp)82765294c1fSJeff Layton __nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, umode_t type,
828999448a8SBernd Schubert int may_flags, struct file **filp)
8291da177e4SLinus Torvalds {
830765927b2SAl Viro struct path path;
8311da177e4SLinus Torvalds struct inode *inode;
8328519f994SKinglong Mee struct file *file;
8336264d69dSAl Viro int flags = O_RDONLY|O_LARGEFILE;
83483f8fc2cSTrond Myklebust int host_err = -EPERM;
8351da177e4SLinus Torvalds
836765927b2SAl Viro path.mnt = fhp->fh_export->ex_path.mnt;
837765927b2SAl Viro path.dentry = fhp->fh_dentry;
8382b0143b5SDavid Howells inode = d_inode(path.dentry);
8391da177e4SLinus Torvalds
840999448a8SBernd Schubert if (IS_APPEND(inode) && (may_flags & NFSD_MAY_WRITE))
8411da177e4SLinus Torvalds goto out;
8421da177e4SLinus Torvalds
8431da177e4SLinus Torvalds if (!inode->i_fop)
8441da177e4SLinus Torvalds goto out;
8451da177e4SLinus Torvalds
846999448a8SBernd Schubert host_err = nfsd_open_break_lease(inode, may_flags);
8476264d69dSAl Viro if (host_err) /* NOMEM or WOULDBLOCK */
84883f8fc2cSTrond Myklebust goto out;
8491da177e4SLinus Torvalds
850999448a8SBernd Schubert if (may_flags & NFSD_MAY_WRITE) {
851999448a8SBernd Schubert if (may_flags & NFSD_MAY_READ)
8529ecb6a08SJ. Bruce Fields flags = O_RDWR|O_LARGEFILE;
8539ecb6a08SJ. Bruce Fields else
8541da177e4SLinus Torvalds flags = O_WRONLY|O_LARGEFILE;
8551da177e4SLinus Torvalds }
856999448a8SBernd Schubert
8578519f994SKinglong Mee file = dentry_open(&path, flags, current_cred());
8588519f994SKinglong Mee if (IS_ERR(file)) {
8598519f994SKinglong Mee host_err = PTR_ERR(file);
86083f8fc2cSTrond Myklebust goto out;
86106effdbbSBernd Schubert }
86206effdbbSBernd Schubert
8636035a27bSAl Viro host_err = ima_file_check(file, may_flags);
8648519f994SKinglong Mee if (host_err) {
865fd891454SChristoph Hellwig fput(file);
86683f8fc2cSTrond Myklebust goto out;
8678519f994SKinglong Mee }
8688519f994SKinglong Mee
8698519f994SKinglong Mee if (may_flags & NFSD_MAY_64BIT_COOKIE)
8708519f994SKinglong Mee file->f_mode |= FMODE_64BITHASH;
8718519f994SKinglong Mee else
8728519f994SKinglong Mee file->f_mode |= FMODE_32BITHASH;
8738519f994SKinglong Mee
8748519f994SKinglong Mee *filp = file;
8751da177e4SLinus Torvalds out:
87683f8fc2cSTrond Myklebust return host_err;
87765294c1fSJeff Layton }
87865294c1fSJeff Layton
87965294c1fSJeff Layton __be32
nfsd_open(struct svc_rqst * rqstp,struct svc_fh * fhp,umode_t type,int may_flags,struct file ** filp)88065294c1fSJeff Layton nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, umode_t type,
88165294c1fSJeff Layton int may_flags, struct file **filp)
88265294c1fSJeff Layton {
88365294c1fSJeff Layton __be32 err;
88483f8fc2cSTrond Myklebust int host_err;
88512bcbd40SJeff Layton bool retried = false;
88665294c1fSJeff Layton
88765294c1fSJeff Layton /*
88865294c1fSJeff Layton * If we get here, then the client has already done an "open",
88965294c1fSJeff Layton * and (hopefully) checked permission - so allow OWNER_OVERRIDE
89065294c1fSJeff Layton * in case a chmod has now revoked permission.
89165294c1fSJeff Layton *
89265294c1fSJeff Layton * Arguably we should also allow the owner override for
89365294c1fSJeff Layton * directories, but we never have and it doesn't seem to have
89465294c1fSJeff Layton * caused anyone a problem. If we were to change this, note
89565294c1fSJeff Layton * also that our filldir callbacks would need a variant of
89665294c1fSJeff Layton * lookup_one_len that doesn't check permissions.
89765294c1fSJeff Layton */
89865294c1fSJeff Layton if (type == S_IFREG)
89965294c1fSJeff Layton may_flags |= NFSD_MAY_OWNER_OVERRIDE;
90012bcbd40SJeff Layton retry:
90165294c1fSJeff Layton err = fh_verify(rqstp, fhp, type, may_flags);
90212bcbd40SJeff Layton if (!err) {
90383f8fc2cSTrond Myklebust host_err = __nfsd_open(rqstp, fhp, type, may_flags, filp);
90483f8fc2cSTrond Myklebust if (host_err == -EOPENSTALE && !retried) {
90512bcbd40SJeff Layton retried = true;
90612bcbd40SJeff Layton fh_put(fhp);
90712bcbd40SJeff Layton goto retry;
90812bcbd40SJeff Layton }
90983f8fc2cSTrond Myklebust err = nfserrno(host_err);
91012bcbd40SJeff Layton }
9111da177e4SLinus Torvalds return err;
9121da177e4SLinus Torvalds }
9131da177e4SLinus Torvalds
914f4d84c52SChuck Lever /**
915f4d84c52SChuck Lever * nfsd_open_verified - Open a regular file for the filecache
916f4d84c52SChuck Lever * @rqstp: RPC request
917f4d84c52SChuck Lever * @fhp: NFS filehandle of the file to open
918f4d84c52SChuck Lever * @may_flags: internal permission flags
919f4d84c52SChuck Lever * @filp: OUT: open "struct file *"
920f4d84c52SChuck Lever *
92183f8fc2cSTrond Myklebust * Returns zero on success, or a negative errno value.
922f4d84c52SChuck Lever */
92383f8fc2cSTrond Myklebust int
nfsd_open_verified(struct svc_rqst * rqstp,struct svc_fh * fhp,int may_flags,struct file ** filp)924f4d84c52SChuck Lever nfsd_open_verified(struct svc_rqst *rqstp, struct svc_fh *fhp, int may_flags,
925f4d84c52SChuck Lever struct file **filp)
92665294c1fSJeff Layton {
927207f135dSJens Axboe return __nfsd_open(rqstp, fhp, S_IFREG, may_flags, filp);
92865294c1fSJeff Layton }
92965294c1fSJeff Layton
9301da177e4SLinus Torvalds /*
931cf8208d0SJens Axboe * Grab and keep cached pages associated with a file in the svc_rqst
932dc97391eSDavid Howells * so that they can be passed to the network sendmsg routines
933cf8208d0SJens Axboe * directly. They will be released after the sending has completed.
9340f516248SChuck Lever *
9350f516248SChuck Lever * Return values: Number of bytes consumed, or -EIO if there are no
9360f516248SChuck Lever * remaining pages in rqstp->rq_pages.
9371da177e4SLinus Torvalds */
9381da177e4SLinus Torvalds static int
nfsd_splice_actor(struct pipe_inode_info * pipe,struct pipe_buffer * buf,struct splice_desc * sd)939cf8208d0SJens Axboe nfsd_splice_actor(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
940cf8208d0SJens Axboe struct splice_desc *sd)
9411da177e4SLinus Torvalds {
942cf8208d0SJens Axboe struct svc_rqst *rqstp = sd->u.data;
943bfbfb618SAl Viro struct page *page = buf->page; // may be a compound one
944bfbfb618SAl Viro unsigned offset = buf->offset;
945ac8db824SChuck Lever struct page *last_page;
9461da177e4SLinus Torvalds
947ac8db824SChuck Lever last_page = page + (offset + sd->len - 1) / PAGE_SIZE;
94827c934ddSJeff Layton for (page += offset / PAGE_SIZE; page <= last_page; page++) {
94927c934ddSJeff Layton /*
950101df45eSDavid Howells * Skip page replacement when extending the contents of the
951101df45eSDavid Howells * current page. But note that we may get two zero_pages in a
952101df45eSDavid Howells * row from shmem.
95327c934ddSJeff Layton */
954101df45eSDavid Howells if (page == *(rqstp->rq_next_page - 1) &&
955101df45eSDavid Howells offset_in_page(rqstp->rq_res.page_base +
956101df45eSDavid Howells rqstp->rq_res.page_len))
95727c934ddSJeff Layton continue;
9580f516248SChuck Lever if (unlikely(!svc_rqst_replace_page(rqstp, page)))
9590f516248SChuck Lever return -EIO;
96027c934ddSJeff Layton }
961bfbfb618SAl Viro if (rqstp->rq_res.page_len == 0) // first call
962bfbfb618SAl Viro rqstp->rq_res.page_base = offset % PAGE_SIZE;
963c7e0b781SChuck Lever rqstp->rq_res.page_len += sd->len;
964c7e0b781SChuck Lever return sd->len;
9651da177e4SLinus Torvalds }
9661da177e4SLinus Torvalds
nfsd_direct_splice_actor(struct pipe_inode_info * pipe,struct splice_desc * sd)967cf8208d0SJens Axboe static int nfsd_direct_splice_actor(struct pipe_inode_info *pipe,
968cf8208d0SJens Axboe struct splice_desc *sd)
969cf8208d0SJens Axboe {
970cf8208d0SJens Axboe return __splice_from_pipe(pipe, sd, nfsd_splice_actor);
971cf8208d0SJens Axboe }
972cf8208d0SJens Axboe
nfsd_eof_on_read(struct file * file,loff_t offset,ssize_t len,size_t expected)97383a63072STrond Myklebust static u32 nfsd_eof_on_read(struct file *file, loff_t offset, ssize_t len,
97483a63072STrond Myklebust size_t expected)
97583a63072STrond Myklebust {
97683a63072STrond Myklebust if (expected != 0 && len == 0)
97783a63072STrond Myklebust return 1;
97883a63072STrond Myklebust if (offset+len >= i_size_read(file_inode(file)))
97983a63072STrond Myklebust return 1;
98083a63072STrond Myklebust return 0;
98183a63072STrond Myklebust }
98283a63072STrond Myklebust
nfsd_finish_read(struct svc_rqst * rqstp,struct svc_fh * fhp,struct file * file,loff_t offset,unsigned long * count,u32 * eof,ssize_t host_err)98387c5942eSChuck Lever static __be32 nfsd_finish_read(struct svc_rqst *rqstp, struct svc_fh *fhp,
98487c5942eSChuck Lever struct file *file, loff_t offset,
98583a63072STrond Myklebust unsigned long *count, u32 *eof, ssize_t host_err)
9861da177e4SLinus Torvalds {
987dc97618dSJ. Bruce Fields if (host_err >= 0) {
988*b670a598SJosef Bacik struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
989*b670a598SJosef Bacik
990*b670a598SJosef Bacik nfsd_stats_io_read_add(nn, fhp->fh_export, host_err);
99183a63072STrond Myklebust *eof = nfsd_eof_on_read(file, offset, host_err, *count);
992dc97618dSJ. Bruce Fields *count = host_err;
993dc97618dSJ. Bruce Fields fsnotify_access(file);
99487c5942eSChuck Lever trace_nfsd_read_io_done(rqstp, fhp, offset, *count);
995dc97618dSJ. Bruce Fields return 0;
99687c5942eSChuck Lever } else {
99787c5942eSChuck Lever trace_nfsd_read_err(rqstp, fhp, offset, host_err);
998dc97618dSJ. Bruce Fields return nfserrno(host_err);
999dc97618dSJ. Bruce Fields }
100087c5942eSChuck Lever }
10011da177e4SLinus Torvalds
1002703d7521SChuck Lever /**
1003703d7521SChuck Lever * nfsd_splice_read - Perform a VFS read using a splice pipe
1004703d7521SChuck Lever * @rqstp: RPC transaction context
1005703d7521SChuck Lever * @fhp: file handle of file to be read
1006703d7521SChuck Lever * @file: opened struct file of file to be read
1007703d7521SChuck Lever * @offset: starting byte offset
1008703d7521SChuck Lever * @count: IN: requested number of bytes; OUT: number of bytes read
1009703d7521SChuck Lever * @eof: OUT: set non-zero if operation reached the end of the file
1010703d7521SChuck Lever *
1011703d7521SChuck Lever * Returns nfs_ok on success, otherwise an nfserr stat value is
1012703d7521SChuck Lever * returned.
1013703d7521SChuck Lever */
nfsd_splice_read(struct svc_rqst * rqstp,struct svc_fh * fhp,struct file * file,loff_t offset,unsigned long * count,u32 * eof)101487c5942eSChuck Lever __be32 nfsd_splice_read(struct svc_rqst *rqstp, struct svc_fh *fhp,
101583a63072STrond Myklebust struct file *file, loff_t offset, unsigned long *count,
101683a63072STrond Myklebust u32 *eof)
1017dc97618dSJ. Bruce Fields {
1018cf8208d0SJens Axboe struct splice_desc sd = {
1019cf8208d0SJens Axboe .len = 0,
1020cf8208d0SJens Axboe .total_len = *count,
1021cf8208d0SJens Axboe .pos = offset,
1022cf8208d0SJens Axboe .u.data = rqstp,
1023cf8208d0SJens Axboe };
102483a63072STrond Myklebust ssize_t host_err;
1025cf8208d0SJens Axboe
102687c5942eSChuck Lever trace_nfsd_read_splice(rqstp, fhp, offset, *count);
1027cf8208d0SJens Axboe host_err = splice_direct_to_actor(file, &sd, nfsd_direct_splice_actor);
102883a63072STrond Myklebust return nfsd_finish_read(rqstp, fhp, file, offset, count, eof, host_err);
1029dc97618dSJ. Bruce Fields }
1030dc97618dSJ. Bruce Fields
1031507df40eSChuck Lever /**
1032507df40eSChuck Lever * nfsd_iter_read - Perform a VFS read using an iterator
1033507df40eSChuck Lever * @rqstp: RPC transaction context
1034507df40eSChuck Lever * @fhp: file handle of file to be read
1035507df40eSChuck Lever * @file: opened struct file of file to be read
1036507df40eSChuck Lever * @offset: starting byte offset
1037507df40eSChuck Lever * @count: IN: requested number of bytes; OUT: number of bytes read
1038507df40eSChuck Lever * @base: offset in first page of read buffer
1039507df40eSChuck Lever * @eof: OUT: set non-zero if operation reached the end of the file
1040507df40eSChuck Lever *
1041507df40eSChuck Lever * Some filesystems or situations cannot use nfsd_splice_read. This
1042507df40eSChuck Lever * function is the slightly less-performant fallback for those cases.
1043507df40eSChuck Lever *
1044507df40eSChuck Lever * Returns nfs_ok on success, otherwise an nfserr stat value is
1045507df40eSChuck Lever * returned.
1046507df40eSChuck Lever */
nfsd_iter_read(struct svc_rqst * rqstp,struct svc_fh * fhp,struct file * file,loff_t offset,unsigned long * count,unsigned int base,u32 * eof)1047507df40eSChuck Lever __be32 nfsd_iter_read(struct svc_rqst *rqstp, struct svc_fh *fhp,
1048507df40eSChuck Lever struct file *file, loff_t offset, unsigned long *count,
1049507df40eSChuck Lever unsigned int base, u32 *eof)
1050507df40eSChuck Lever {
1051507df40eSChuck Lever unsigned long v, total;
1052507df40eSChuck Lever struct iov_iter iter;
1053507df40eSChuck Lever loff_t ppos = offset;
1054507df40eSChuck Lever struct page *page;
1055507df40eSChuck Lever ssize_t host_err;
1056507df40eSChuck Lever
1057507df40eSChuck Lever v = 0;
1058507df40eSChuck Lever total = *count;
1059507df40eSChuck Lever while (total) {
1060507df40eSChuck Lever page = *(rqstp->rq_next_page++);
1061507df40eSChuck Lever rqstp->rq_vec[v].iov_base = page_address(page) + base;
1062507df40eSChuck Lever rqstp->rq_vec[v].iov_len = min_t(size_t, total, PAGE_SIZE - base);
1063507df40eSChuck Lever total -= rqstp->rq_vec[v].iov_len;
1064507df40eSChuck Lever ++v;
1065507df40eSChuck Lever base = 0;
1066507df40eSChuck Lever }
1067507df40eSChuck Lever WARN_ON_ONCE(v > ARRAY_SIZE(rqstp->rq_vec));
1068507df40eSChuck Lever
1069507df40eSChuck Lever trace_nfsd_read_vector(rqstp, fhp, offset, *count);
1070507df40eSChuck Lever iov_iter_kvec(&iter, ITER_DEST, rqstp->rq_vec, v, *count);
1071507df40eSChuck Lever host_err = vfs_iter_read(file, &iter, &ppos, 0);
1072507df40eSChuck Lever return nfsd_finish_read(rqstp, fhp, file, offset, count, eof, host_err);
1073507df40eSChuck Lever }
1074507df40eSChuck Lever
1075d911df7bSJ. Bruce Fields /*
1076d911df7bSJ. Bruce Fields * Gathered writes: If another process is currently writing to the file,
1077d911df7bSJ. Bruce Fields * there's a high chance this is another nfsd (triggered by a bulk write
1078d911df7bSJ. Bruce Fields * from a client's biod). Rather than syncing the file with each write
1079d911df7bSJ. Bruce Fields * request, we sleep for 10 msec.
1080d911df7bSJ. Bruce Fields *
1081d911df7bSJ. Bruce Fields * I don't know if this roughly approximates C. Juszak's idea of
1082d911df7bSJ. Bruce Fields * gathered writes, but it's a nice and simple solution (IMHO), and it
1083d911df7bSJ. Bruce Fields * seems to work:-)
1084d911df7bSJ. Bruce Fields *
1085d911df7bSJ. Bruce Fields * Note: we do this only in the NFSv2 case, since v3 and higher have a
1086d911df7bSJ. Bruce Fields * better tool (separate unstable writes and commits) for solving this
1087d911df7bSJ. Bruce Fields * problem.
1088d911df7bSJ. Bruce Fields */
wait_for_concurrent_writes(struct file * file)1089d911df7bSJ. Bruce Fields static int wait_for_concurrent_writes(struct file *file)
1090d911df7bSJ. Bruce Fields {
1091496ad9aaSAl Viro struct inode *inode = file_inode(file);
1092d911df7bSJ. Bruce Fields static ino_t last_ino;
1093d911df7bSJ. Bruce Fields static dev_t last_dev;
1094d911df7bSJ. Bruce Fields int err = 0;
1095d911df7bSJ. Bruce Fields
1096d911df7bSJ. Bruce Fields if (atomic_read(&inode->i_writecount) > 1
1097d911df7bSJ. Bruce Fields || (last_ino == inode->i_ino && last_dev == inode->i_sb->s_dev)) {
1098d911df7bSJ. Bruce Fields dprintk("nfsd: write defer %d\n", task_pid_nr(current));
1099d911df7bSJ. Bruce Fields msleep(10);
1100d911df7bSJ. Bruce Fields dprintk("nfsd: write resume %d\n", task_pid_nr(current));
1101d911df7bSJ. Bruce Fields }
1102d911df7bSJ. Bruce Fields
1103d911df7bSJ. Bruce Fields if (inode->i_state & I_DIRTY) {
1104d911df7bSJ. Bruce Fields dprintk("nfsd: write sync %d\n", task_pid_nr(current));
11058018ab05SChristoph Hellwig err = vfs_fsync(file, 0);
1106d911df7bSJ. Bruce Fields }
1107d911df7bSJ. Bruce Fields last_ino = inode->i_ino;
1108d911df7bSJ. Bruce Fields last_dev = inode->i_sb->s_dev;
1109d911df7bSJ. Bruce Fields return err;
1110d911df7bSJ. Bruce Fields }
1111d911df7bSJ. Bruce Fields
1112af90f707SChristoph Hellwig __be32
nfsd_vfs_write(struct svc_rqst * rqstp,struct svc_fh * fhp,struct nfsd_file * nf,loff_t offset,struct kvec * vec,int vlen,unsigned long * cnt,int stable,__be32 * verf)111316f8f894STrond Myklebust nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct nfsd_file *nf,
11141da177e4SLinus Torvalds loff_t offset, struct kvec *vec, int vlen,
111519e0663fSTrond Myklebust unsigned long *cnt, int stable,
111619e0663fSTrond Myklebust __be32 *verf)
11171da177e4SLinus Torvalds {
1118fb7622c2SChuck Lever struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
111916f8f894STrond Myklebust struct file *file = nf->nf_file;
112001cbf385STrond Myklebust struct super_block *sb = file_inode(file)->i_sb;
11211da177e4SLinus Torvalds struct svc_export *exp;
112273da852eSChristoph Hellwig struct iov_iter iter;
1123555dbf1aSTrond Myklebust errseq_t since;
1124d890be15SChuck Lever __be32 nfserr;
11256264d69dSAl Viro int host_err;
112648e03bc5STrond Myklebust int use_wgather;
1127e49dbbf3SKent Overstreet loff_t pos = offset;
112801cbf385STrond Myklebust unsigned long exp_op_flags = 0;
11298658452eSNeilBrown unsigned int pflags = current->flags;
1130ddef7ed2SChristoph Hellwig rwf_t flags = 0;
113101cbf385STrond Myklebust bool restore_flags = false;
11328658452eSNeilBrown
1133d890be15SChuck Lever trace_nfsd_write_opened(rqstp, fhp, offset, *cnt);
1134d890be15SChuck Lever
113501cbf385STrond Myklebust if (sb->s_export_op)
113601cbf385STrond Myklebust exp_op_flags = sb->s_export_op->flags;
113701cbf385STrond Myklebust
113801cbf385STrond Myklebust if (test_bit(RQ_LOCAL, &rqstp->rq_flags) &&
113901cbf385STrond Myklebust !(exp_op_flags & EXPORT_OP_REMOTE_FS)) {
11408658452eSNeilBrown /*
1141a37b0715SNeilBrown * We want throttling in balance_dirty_pages()
1142a37b0715SNeilBrown * and shrink_inactive_list() to only consider
1143a37b0715SNeilBrown * the backingdev we are writing to, so that nfs to
11448658452eSNeilBrown * localhost doesn't cause nfsd to lock up due to all
11458658452eSNeilBrown * the client's dirty pages or its congested queue.
11468658452eSNeilBrown */
1147a37b0715SNeilBrown current->flags |= PF_LOCAL_THROTTLE;
114801cbf385STrond Myklebust restore_flags = true;
114901cbf385STrond Myklebust }
11501da177e4SLinus Torvalds
11511da177e4SLinus Torvalds exp = fhp->fh_export;
115248e03bc5STrond Myklebust use_wgather = (rqstp->rq_vers == 2) && EX_WGATHER(exp);
11531da177e4SLinus Torvalds
11541da177e4SLinus Torvalds if (!EX_ISSYNC(exp))
115554bbb7d2SKinglong Mee stable = NFS_UNSTABLE;
11561da177e4SLinus Torvalds
115724368aadSChristoph Hellwig if (stable && !use_wgather)
115824368aadSChristoph Hellwig flags |= RWF_SYNC;
115924368aadSChristoph Hellwig
1160de4eda9dSAl Viro iov_iter_kvec(&iter, ITER_SOURCE, vec, vlen, *cnt);
1161555dbf1aSTrond Myklebust since = READ_ONCE(file->f_wb_err);
1162f11ad7aaSChuck Lever if (verf)
11633988a578SChuck Lever nfsd_copy_write_verifier(verf, nn);
1164fd9a2e1dSChuck Lever file_start_write(file);
116573da852eSChristoph Hellwig host_err = vfs_iter_write(file, &iter, &pos, flags);
1166fd9a2e1dSChuck Lever file_end_write(file);
11677bf94c6bSTrond Myklebust if (host_err < 0) {
11683988a578SChuck Lever nfsd_reset_write_verifier(nn);
116975acacb6SChuck Lever trace_nfsd_writeverf_reset(nn, rqstp, host_err);
1170e4636d53SJ. Bruce Fields goto out_nfserr;
11717bf94c6bSTrond Myklebust }
117209a80f2aSTrond Myklebust *cnt = host_err;
1173*b670a598SJosef Bacik nfsd_stats_io_write_add(nn, exp, *cnt);
11742a12a9d7SEric Paris fsnotify_modify(file);
1175555dbf1aSTrond Myklebust host_err = filemap_check_wb_err(file->f_mapping, since);
1176555dbf1aSTrond Myklebust if (host_err < 0)
1177555dbf1aSTrond Myklebust goto out_nfserr;
11781da177e4SLinus Torvalds
1179bbf2f098STrond Myklebust if (stable && use_wgather) {
1180d911df7bSJ. Bruce Fields host_err = wait_for_concurrent_writes(file);
118175acacb6SChuck Lever if (host_err < 0) {
11823988a578SChuck Lever nfsd_reset_write_verifier(nn);
118375acacb6SChuck Lever trace_nfsd_writeverf_reset(nn, rqstp, host_err);
118475acacb6SChuck Lever }
1185bbf2f098STrond Myklebust }
11861da177e4SLinus Torvalds
1187e4636d53SJ. Bruce Fields out_nfserr:
1188d890be15SChuck Lever if (host_err >= 0) {
1189d890be15SChuck Lever trace_nfsd_write_io_done(rqstp, fhp, offset, *cnt);
1190d890be15SChuck Lever nfserr = nfs_ok;
1191d890be15SChuck Lever } else {
1192d890be15SChuck Lever trace_nfsd_write_err(rqstp, fhp, offset, host_err);
1193d890be15SChuck Lever nfserr = nfserrno(host_err);
1194d890be15SChuck Lever }
119501cbf385STrond Myklebust if (restore_flags)
1196a37b0715SNeilBrown current_restore_flags(pflags, PF_LOCAL_THROTTLE);
1197d890be15SChuck Lever return nfserr;
11981da177e4SLinus Torvalds }
11991da177e4SLinus Torvalds
1200507df40eSChuck Lever /**
1201507df40eSChuck Lever * nfsd_read - Read data from a file
1202507df40eSChuck Lever * @rqstp: RPC transaction context
1203507df40eSChuck Lever * @fhp: file handle of file to be read
1204507df40eSChuck Lever * @offset: starting byte offset
1205507df40eSChuck Lever * @count: IN: requested number of bytes; OUT: number of bytes read
1206507df40eSChuck Lever * @eof: OUT: set non-zero if operation reached the end of the file
1207507df40eSChuck Lever *
1208507df40eSChuck Lever * The caller must verify that there is enough space in @rqstp.rq_res
1209507df40eSChuck Lever * to perform this operation.
1210507df40eSChuck Lever *
1211dc97618dSJ. Bruce Fields * N.B. After this call fhp needs an fh_put
1212507df40eSChuck Lever *
1213507df40eSChuck Lever * Returns nfs_ok on success, otherwise an nfserr stat value is
1214507df40eSChuck Lever * returned.
1215dc97618dSJ. Bruce Fields */
nfsd_read(struct svc_rqst * rqstp,struct svc_fh * fhp,loff_t offset,unsigned long * count,u32 * eof)1216dc97618dSJ. Bruce Fields __be32 nfsd_read(struct svc_rqst *rqstp, struct svc_fh *fhp,
1217507df40eSChuck Lever loff_t offset, unsigned long *count, u32 *eof)
1218dc97618dSJ. Bruce Fields {
121948cd7b51SJeff Layton struct nfsd_file *nf;
1220dc97618dSJ. Bruce Fields struct file *file;
1221dc97618dSJ. Bruce Fields __be32 err;
1222dc97618dSJ. Bruce Fields
1223f394b62bSChuck Lever trace_nfsd_read_start(rqstp, fhp, offset, *count);
12244d1ea845SChuck Lever err = nfsd_file_acquire_gc(rqstp, fhp, NFSD_MAY_READ, &nf);
1225dc97618dSJ. Bruce Fields if (err)
1226dc97618dSJ. Bruce Fields return err;
1227dc97618dSJ. Bruce Fields
122848cd7b51SJeff Layton file = nf->nf_file;
1229a4058c5bSChristoph Hellwig if (file->f_op->splice_read && test_bit(RQ_SPLICE_OK, &rqstp->rq_flags))
123083a63072STrond Myklebust err = nfsd_splice_read(rqstp, fhp, file, offset, count, eof);
1231a4058c5bSChristoph Hellwig else
1232507df40eSChuck Lever err = nfsd_iter_read(rqstp, fhp, file, offset, count, 0, eof);
12336e8b50d1SJeff Layton
123448cd7b51SJeff Layton nfsd_file_put(nf);
1235f394b62bSChuck Lever trace_nfsd_read_done(rqstp, fhp, offset, *count);
1236fa0a2126SJ. Bruce Fields return err;
1237fa0a2126SJ. Bruce Fields }
1238fa0a2126SJ. Bruce Fields
12391da177e4SLinus Torvalds /*
12401da177e4SLinus Torvalds * Write data to a file.
12411da177e4SLinus Torvalds * The stable flag requests synchronous writes.
12421da177e4SLinus Torvalds * N.B. After this call fhp needs an fh_put
12431da177e4SLinus Torvalds */
12446264d69dSAl Viro __be32
nfsd_write(struct svc_rqst * rqstp,struct svc_fh * fhp,loff_t offset,struct kvec * vec,int vlen,unsigned long * cnt,int stable,__be32 * verf)124552e380e0SKinglong Mee nfsd_write(struct svc_rqst *rqstp, struct svc_fh *fhp, loff_t offset,
124619e0663fSTrond Myklebust struct kvec *vec, int vlen, unsigned long *cnt, int stable,
124719e0663fSTrond Myklebust __be32 *verf)
12481da177e4SLinus Torvalds {
1249b4935239SJeff Layton struct nfsd_file *nf;
1250b4935239SJeff Layton __be32 err;
12511da177e4SLinus Torvalds
1252f394b62bSChuck Lever trace_nfsd_write_start(rqstp, fhp, offset, *cnt);
12536e8b50d1SJeff Layton
12544d1ea845SChuck Lever err = nfsd_file_acquire_gc(rqstp, fhp, NFSD_MAY_WRITE, &nf);
12551da177e4SLinus Torvalds if (err)
12561da177e4SLinus Torvalds goto out;
12571da177e4SLinus Torvalds
125816f8f894STrond Myklebust err = nfsd_vfs_write(rqstp, fhp, nf, offset, vec,
125919e0663fSTrond Myklebust vlen, cnt, stable, verf);
1260b4935239SJeff Layton nfsd_file_put(nf);
12611da177e4SLinus Torvalds out:
1262f394b62bSChuck Lever trace_nfsd_write_done(rqstp, fhp, offset, *cnt);
12631da177e4SLinus Torvalds return err;
12641da177e4SLinus Torvalds }
12651da177e4SLinus Torvalds
12663f965021SChuck Lever /**
12673f965021SChuck Lever * nfsd_commit - Commit pending writes to stable storage
12683f965021SChuck Lever * @rqstp: RPC request being processed
12693f965021SChuck Lever * @fhp: NFS filehandle
1270c2528490SChuck Lever * @nf: target file
12713f965021SChuck Lever * @offset: raw offset from beginning of file
12723f965021SChuck Lever * @count: raw count of bytes to sync
12733f965021SChuck Lever * @verf: filled in with the server's current write verifier
1274aa696a6fSTrond Myklebust *
12753f965021SChuck Lever * Note: we guarantee that data that lies within the range specified
12763f965021SChuck Lever * by the 'offset' and 'count' parameters will be synced. The server
12773f965021SChuck Lever * is permitted to sync data that lies outside this range at the
12783f965021SChuck Lever * same time.
12791da177e4SLinus Torvalds *
12801da177e4SLinus Torvalds * Unfortunately we cannot lock the file to make sure we return full WCC
12811da177e4SLinus Torvalds * data to the client, as locking happens lower down in the filesystem.
12823f965021SChuck Lever *
12833f965021SChuck Lever * Return values:
12843f965021SChuck Lever * An nfsstat value in network byte order.
12851da177e4SLinus Torvalds */
12866264d69dSAl Viro __be32
nfsd_commit(struct svc_rqst * rqstp,struct svc_fh * fhp,struct nfsd_file * nf,u64 offset,u32 count,__be32 * verf)1287c2528490SChuck Lever nfsd_commit(struct svc_rqst *rqstp, struct svc_fh *fhp, struct nfsd_file *nf,
1288c2528490SChuck Lever u64 offset, u32 count, __be32 *verf)
12891da177e4SLinus Torvalds {
1290c2528490SChuck Lever __be32 err = nfs_ok;
12913f965021SChuck Lever u64 maxbytes;
12923f965021SChuck Lever loff_t start, end;
12932c445a0eSChuck Lever struct nfsd_net *nn;
12943f965021SChuck Lever
12953f965021SChuck Lever /*
12963f965021SChuck Lever * Convert the client-provided (offset, count) range to a
12973f965021SChuck Lever * (start, end) range. If the client-provided range falls
12983f965021SChuck Lever * outside the maximum file size of the underlying FS,
12993f965021SChuck Lever * clamp the sync range appropriately.
13003f965021SChuck Lever */
13013f965021SChuck Lever start = 0;
13023f965021SChuck Lever end = LLONG_MAX;
13033f965021SChuck Lever maxbytes = (u64)fhp->fh_dentry->d_sb->s_maxbytes;
13043f965021SChuck Lever if (offset < maxbytes) {
13053f965021SChuck Lever start = offset;
13063f965021SChuck Lever if (count && (offset + count - 1 < maxbytes))
13073f965021SChuck Lever end = offset + count - 1;
13083f965021SChuck Lever }
13093f965021SChuck Lever
13102c445a0eSChuck Lever nn = net_generic(nf->nf_net, nfsd_net_id);
13111da177e4SLinus Torvalds if (EX_ISSYNC(fhp->fh_export)) {
1312555dbf1aSTrond Myklebust errseq_t since = READ_ONCE(nf->nf_file->f_wb_err);
1313555dbf1aSTrond Myklebust int err2;
1314aa696a6fSTrond Myklebust
13153f965021SChuck Lever err2 = vfs_fsync_range(nf->nf_file, start, end, 0);
1316bbf2f098STrond Myklebust switch (err2) {
1317bbf2f098STrond Myklebust case 0:
13183988a578SChuck Lever nfsd_copy_write_verifier(verf, nn);
1319555dbf1aSTrond Myklebust err2 = filemap_check_wb_err(nf->nf_file->f_mapping,
1320555dbf1aSTrond Myklebust since);
13218a9ffb8cSAlexey Khoroshilov err = nfserrno(err2);
1322bbf2f098STrond Myklebust break;
1323bbf2f098STrond Myklebust case -EINVAL:
13241da177e4SLinus Torvalds err = nfserr_notsupp;
1325bbf2f098STrond Myklebust break;
1326bbf2f098STrond Myklebust default:
13273988a578SChuck Lever nfsd_reset_write_verifier(nn);
132875acacb6SChuck Lever trace_nfsd_writeverf_reset(nn, rqstp, err2);
1329555dbf1aSTrond Myklebust err = nfserrno(err2);
13308a9ffb8cSAlexey Khoroshilov }
1331524ff1afSTrond Myklebust } else
13323988a578SChuck Lever nfsd_copy_write_verifier(verf, nn);
13331da177e4SLinus Torvalds
13341da177e4SLinus Torvalds return err;
13351da177e4SLinus Torvalds }
13361da177e4SLinus Torvalds
13375f46e950SChuck Lever /**
13385f46e950SChuck Lever * nfsd_create_setattr - Set a created file's attributes
13395f46e950SChuck Lever * @rqstp: RPC transaction being executed
13405f46e950SChuck Lever * @fhp: NFS filehandle of parent directory
13415f46e950SChuck Lever * @resfhp: NFS filehandle of new object
13427fe2a71dSNeilBrown * @attrs: requested attributes of new object
13435f46e950SChuck Lever *
13445f46e950SChuck Lever * Returns nfs_ok on success, or an nfsstat in network byte order.
13455f46e950SChuck Lever */
13465f46e950SChuck Lever __be32
nfsd_create_setattr(struct svc_rqst * rqstp,struct svc_fh * fhp,struct svc_fh * resfhp,struct nfsd_attrs * attrs)13475f46e950SChuck Lever nfsd_create_setattr(struct svc_rqst *rqstp, struct svc_fh *fhp,
13487fe2a71dSNeilBrown struct svc_fh *resfhp, struct nfsd_attrs *attrs)
13495c002b3bSJ. Bruce Fields {
13507fe2a71dSNeilBrown struct iattr *iap = attrs->na_iattr;
13515f46e950SChuck Lever __be32 status;
13525f46e950SChuck Lever
13535c002b3bSJ. Bruce Fields /*
13545f46e950SChuck Lever * Mode has already been set by file creation.
13555c002b3bSJ. Bruce Fields */
13565c002b3bSJ. Bruce Fields iap->ia_valid &= ~ATTR_MODE;
13575f46e950SChuck Lever
13585c002b3bSJ. Bruce Fields /*
13595c002b3bSJ. Bruce Fields * Setting uid/gid works only for root. Irix appears to
13605c002b3bSJ. Bruce Fields * send along the gid on create when it tries to implement
13615c002b3bSJ. Bruce Fields * setgid directories via NFS:
13625c002b3bSJ. Bruce Fields */
13636fab8779SEric W. Biederman if (!uid_eq(current_fsuid(), GLOBAL_ROOT_UID))
13645c002b3bSJ. Bruce Fields iap->ia_valid &= ~(ATTR_UID|ATTR_GID);
13655f46e950SChuck Lever
13665f46e950SChuck Lever /*
13675f46e950SChuck Lever * Callers expect new file metadata to be committed even
13685f46e950SChuck Lever * if the attributes have not changed.
13695f46e950SChuck Lever */
13705c002b3bSJ. Bruce Fields if (iap->ia_valid)
13717fe2a71dSNeilBrown status = nfsd_setattr(rqstp, resfhp, attrs, 0, (time64_t)0);
13725f46e950SChuck Lever else
13735f46e950SChuck Lever status = nfserrno(commit_metadata(resfhp));
13745f46e950SChuck Lever
13755f46e950SChuck Lever /*
13765f46e950SChuck Lever * Transactional filesystems had a chance to commit changes
13775f46e950SChuck Lever * for both parent and child simultaneously making the
13785f46e950SChuck Lever * following commit_metadata a noop in many cases.
13795f46e950SChuck Lever */
13805f46e950SChuck Lever if (!status)
13815f46e950SChuck Lever status = nfserrno(commit_metadata(fhp));
13825f46e950SChuck Lever
13835f46e950SChuck Lever /*
13845f46e950SChuck Lever * Update the new filehandle to pick up the new attributes.
13855f46e950SChuck Lever */
13865f46e950SChuck Lever if (!status)
13875f46e950SChuck Lever status = fh_update(resfhp);
13885f46e950SChuck Lever
13895f46e950SChuck Lever return status;
13905c002b3bSJ. Bruce Fields }
13915c002b3bSJ. Bruce Fields
13924ac35c2fSwengang wang /* HPUX client sometimes creates a file in mode 000, and sets size to 0.
13934ac35c2fSwengang wang * setting size to 0 may fail for some specific file systems by the permission
13944ac35c2fSwengang wang * checking which requires WRITE permission but the mode is 000.
13954ac35c2fSwengang wang * we ignore the resizing(to 0) on the just new created file, since the size is
13964ac35c2fSwengang wang * 0 after file created.
13974ac35c2fSwengang wang *
13984ac35c2fSwengang wang * call this only after vfs_create() is called.
13994ac35c2fSwengang wang * */
14004ac35c2fSwengang wang static void
nfsd_check_ignore_resizing(struct iattr * iap)14014ac35c2fSwengang wang nfsd_check_ignore_resizing(struct iattr *iap)
14024ac35c2fSwengang wang {
14034ac35c2fSwengang wang if ((iap->ia_valid & ATTR_SIZE) && (iap->ia_size == 0))
14044ac35c2fSwengang wang iap->ia_valid &= ~ATTR_SIZE;
14054ac35c2fSwengang wang }
14064ac35c2fSwengang wang
1407b44061d0SJ. Bruce Fields /* The parent directory should already be locked: */
14086264d69dSAl Viro __be32
nfsd_create_locked(struct svc_rqst * rqstp,struct svc_fh * fhp,struct nfsd_attrs * attrs,int type,dev_t rdev,struct svc_fh * resfhp)1409b44061d0SJ. Bruce Fields nfsd_create_locked(struct svc_rqst *rqstp, struct svc_fh *fhp,
14109558f930SNeilBrown struct nfsd_attrs *attrs,
14111da177e4SLinus Torvalds int type, dev_t rdev, struct svc_fh *resfhp)
14121da177e4SLinus Torvalds {
14132b118859SDan Carpenter struct dentry *dentry, *dchild;
14141da177e4SLinus Torvalds struct inode *dirp;
14157fe2a71dSNeilBrown struct iattr *iap = attrs->na_iattr;
14166264d69dSAl Viro __be32 err;
14176264d69dSAl Viro int host_err;
14181da177e4SLinus Torvalds
14191da177e4SLinus Torvalds dentry = fhp->fh_dentry;
14202b0143b5SDavid Howells dirp = d_inode(dentry);
14211da177e4SLinus Torvalds
14221da177e4SLinus Torvalds dchild = dget(resfhp->fh_dentry);
14237eed34f1SOleg Drokin err = nfsd_permission(rqstp, fhp->fh_export, dentry, NFSD_MAY_CREATE);
14247eed34f1SOleg Drokin if (err)
14257eed34f1SOleg Drokin goto out;
14267eed34f1SOleg Drokin
14271da177e4SLinus Torvalds if (!(iap->ia_valid & ATTR_MODE))
14281da177e4SLinus Torvalds iap->ia_mode = 0;
14291da177e4SLinus Torvalds iap->ia_mode = (iap->ia_mode & S_IALLUGO) | type;
14301da177e4SLinus Torvalds
143122cf8419SJ. Bruce Fields if (!IS_POSIXACL(dirp))
143222cf8419SJ. Bruce Fields iap->ia_mode &= ~current_umask();
143322cf8419SJ. Bruce Fields
1434088406bcSJ. Bruce Fields err = 0;
14351da177e4SLinus Torvalds switch (type) {
14361da177e4SLinus Torvalds case S_IFREG:
1437abf08576SChristian Brauner host_err = vfs_create(&nop_mnt_idmap, dirp, dchild,
1438abf08576SChristian Brauner iap->ia_mode, true);
14394ac35c2fSwengang wang if (!host_err)
14404ac35c2fSwengang wang nfsd_check_ignore_resizing(iap);
14411da177e4SLinus Torvalds break;
14421da177e4SLinus Torvalds case S_IFDIR:
1443abf08576SChristian Brauner host_err = vfs_mkdir(&nop_mnt_idmap, dirp, dchild, iap->ia_mode);
14443819bb0dSAl Viro if (!host_err && unlikely(d_unhashed(dchild))) {
14453819bb0dSAl Viro struct dentry *d;
14463819bb0dSAl Viro d = lookup_one_len(dchild->d_name.name,
14473819bb0dSAl Viro dchild->d_parent,
14483819bb0dSAl Viro dchild->d_name.len);
14493819bb0dSAl Viro if (IS_ERR(d)) {
14503819bb0dSAl Viro host_err = PTR_ERR(d);
14513819bb0dSAl Viro break;
14523819bb0dSAl Viro }
14533819bb0dSAl Viro if (unlikely(d_is_negative(d))) {
14543819bb0dSAl Viro dput(d);
14553819bb0dSAl Viro err = nfserr_serverfault;
14563819bb0dSAl Viro goto out;
14573819bb0dSAl Viro }
14583819bb0dSAl Viro dput(resfhp->fh_dentry);
14593819bb0dSAl Viro resfhp->fh_dentry = dget(d);
14603819bb0dSAl Viro err = fh_update(resfhp);
14613819bb0dSAl Viro dput(dchild);
14623819bb0dSAl Viro dchild = d;
14633819bb0dSAl Viro if (err)
14643819bb0dSAl Viro goto out;
14653819bb0dSAl Viro }
14661da177e4SLinus Torvalds break;
14671da177e4SLinus Torvalds case S_IFCHR:
14681da177e4SLinus Torvalds case S_IFBLK:
14691da177e4SLinus Torvalds case S_IFIFO:
14701da177e4SLinus Torvalds case S_IFSOCK:
1471abf08576SChristian Brauner host_err = vfs_mknod(&nop_mnt_idmap, dirp, dchild,
14726521f891SChristian Brauner iap->ia_mode, rdev);
14731da177e4SLinus Torvalds break;
147471423274SJ. Bruce Fields default:
147571423274SJ. Bruce Fields printk(KERN_WARNING "nfsd: bad file type %o in nfsd_create\n",
147671423274SJ. Bruce Fields type);
147771423274SJ. Bruce Fields host_err = -EINVAL;
1478463c3197SDave Hansen }
14794a55c101SJan Kara if (host_err < 0)
1480463c3197SDave Hansen goto out_nfserr;
14811da177e4SLinus Torvalds
14827fe2a71dSNeilBrown err = nfsd_create_setattr(rqstp, fhp, resfhp, attrs);
14831da177e4SLinus Torvalds
14841da177e4SLinus Torvalds out:
14851da177e4SLinus Torvalds dput(dchild);
14861da177e4SLinus Torvalds return err;
14871da177e4SLinus Torvalds
14881da177e4SLinus Torvalds out_nfserr:
14896264d69dSAl Viro err = nfserrno(host_err);
14901da177e4SLinus Torvalds goto out;
14911da177e4SLinus Torvalds }
14921da177e4SLinus Torvalds
1493b44061d0SJ. Bruce Fields /*
1494b44061d0SJ. Bruce Fields * Create a filesystem object (regular, directory, special).
1495b44061d0SJ. Bruce Fields * Note that the parent directory is left locked.
1496b44061d0SJ. Bruce Fields *
1497b44061d0SJ. Bruce Fields * N.B. Every call to nfsd_create needs an fh_put for _both_ fhp and resfhp
1498b44061d0SJ. Bruce Fields */
1499b44061d0SJ. Bruce Fields __be32
nfsd_create(struct svc_rqst * rqstp,struct svc_fh * fhp,char * fname,int flen,struct nfsd_attrs * attrs,int type,dev_t rdev,struct svc_fh * resfhp)1500b44061d0SJ. Bruce Fields nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
15017fe2a71dSNeilBrown char *fname, int flen, struct nfsd_attrs *attrs,
1502b44061d0SJ. Bruce Fields int type, dev_t rdev, struct svc_fh *resfhp)
1503b44061d0SJ. Bruce Fields {
1504b44061d0SJ. Bruce Fields struct dentry *dentry, *dchild = NULL;
1505b44061d0SJ. Bruce Fields __be32 err;
1506b44061d0SJ. Bruce Fields int host_err;
1507b44061d0SJ. Bruce Fields
1508b44061d0SJ. Bruce Fields if (isdotent(fname, flen))
1509b44061d0SJ. Bruce Fields return nfserr_exist;
1510b44061d0SJ. Bruce Fields
1511fa08139dSJ. Bruce Fields err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_NOP);
1512b44061d0SJ. Bruce Fields if (err)
1513b44061d0SJ. Bruce Fields return err;
1514b44061d0SJ. Bruce Fields
1515b44061d0SJ. Bruce Fields dentry = fhp->fh_dentry;
1516b44061d0SJ. Bruce Fields
1517b44061d0SJ. Bruce Fields host_err = fh_want_write(fhp);
1518b44061d0SJ. Bruce Fields if (host_err)
1519b44061d0SJ. Bruce Fields return nfserrno(host_err);
1520b44061d0SJ. Bruce Fields
1521debf16f0SNeilBrown inode_lock_nested(dentry->d_inode, I_MUTEX_PARENT);
1522b44061d0SJ. Bruce Fields dchild = lookup_one_len(fname, dentry, flen);
1523b44061d0SJ. Bruce Fields host_err = PTR_ERR(dchild);
1524927bfc56SNeilBrown if (IS_ERR(dchild)) {
1525927bfc56SNeilBrown err = nfserrno(host_err);
1526927bfc56SNeilBrown goto out_unlock;
1527927bfc56SNeilBrown }
1528b44061d0SJ. Bruce Fields err = fh_compose(resfhp, fhp->fh_export, dchild, fhp);
1529502aa0a5SJosef Bacik /*
1530502aa0a5SJosef Bacik * We unconditionally drop our ref to dchild as fh_compose will have
1531502aa0a5SJosef Bacik * already grabbed its own ref for it.
1532502aa0a5SJosef Bacik */
1533b44061d0SJ. Bruce Fields dput(dchild);
1534502aa0a5SJosef Bacik if (err)
1535927bfc56SNeilBrown goto out_unlock;
1536a332018aSJeff Layton err = fh_fill_pre_attrs(fhp);
1537a332018aSJeff Layton if (err != nfs_ok)
1538a332018aSJeff Layton goto out_unlock;
15399558f930SNeilBrown err = nfsd_create_locked(rqstp, fhp, attrs, type, rdev, resfhp);
1540debf16f0SNeilBrown fh_fill_post_attrs(fhp);
1541927bfc56SNeilBrown out_unlock:
1542debf16f0SNeilBrown inode_unlock(dentry->d_inode);
1543927bfc56SNeilBrown return err;
1544b44061d0SJ. Bruce Fields }
1545b44061d0SJ. Bruce Fields
15461da177e4SLinus Torvalds /*
15471da177e4SLinus Torvalds * Read a symlink. On entry, *lenp must contain the maximum path length that
15481da177e4SLinus Torvalds * fits into the buffer. On return, it contains the true length.
15491da177e4SLinus Torvalds * N.B. After this call fhp needs an fh_put
15501da177e4SLinus Torvalds */
15516264d69dSAl Viro __be32
nfsd_readlink(struct svc_rqst * rqstp,struct svc_fh * fhp,char * buf,int * lenp)15521da177e4SLinus Torvalds nfsd_readlink(struct svc_rqst *rqstp, struct svc_fh *fhp, char *buf, int *lenp)
15531da177e4SLinus Torvalds {
15546264d69dSAl Viro __be32 err;
15554d7edbc3SAl Viro const char *link;
155668ac1234SAl Viro struct path path;
15574d7edbc3SAl Viro DEFINE_DELAYED_CALL(done);
15584d7edbc3SAl Viro int len;
15591da177e4SLinus Torvalds
15608837abcaSMiklos Szeredi err = fh_verify(rqstp, fhp, S_IFLNK, NFSD_MAY_NOP);
15614d7edbc3SAl Viro if (unlikely(err))
15624d7edbc3SAl Viro return err;
15631da177e4SLinus Torvalds
156468ac1234SAl Viro path.mnt = fhp->fh_export->ex_path.mnt;
156568ac1234SAl Viro path.dentry = fhp->fh_dentry;
15661da177e4SLinus Torvalds
15674d7edbc3SAl Viro if (unlikely(!d_is_symlink(path.dentry)))
15684d7edbc3SAl Viro return nfserr_inval;
15691da177e4SLinus Torvalds
157068ac1234SAl Viro touch_atime(&path);
15711da177e4SLinus Torvalds
15724d7edbc3SAl Viro link = vfs_get_link(path.dentry, &done);
15734d7edbc3SAl Viro if (IS_ERR(link))
15744d7edbc3SAl Viro return nfserrno(PTR_ERR(link));
15751da177e4SLinus Torvalds
15764d7edbc3SAl Viro len = strlen(link);
15774d7edbc3SAl Viro if (len < *lenp)
15784d7edbc3SAl Viro *lenp = len;
15794d7edbc3SAl Viro memcpy(buf, link, *lenp);
15804d7edbc3SAl Viro do_delayed_call(&done);
15814d7edbc3SAl Viro return 0;
15821da177e4SLinus Torvalds }
15831da177e4SLinus Torvalds
158493adc1e3SNeilBrown /**
158593adc1e3SNeilBrown * nfsd_symlink - Create a symlink and look up its inode
158693adc1e3SNeilBrown * @rqstp: RPC transaction being executed
158793adc1e3SNeilBrown * @fhp: NFS filehandle of parent directory
158893adc1e3SNeilBrown * @fname: filename of the new symlink
158993adc1e3SNeilBrown * @flen: length of @fname
159093adc1e3SNeilBrown * @path: content of the new symlink (NUL-terminated)
159193adc1e3SNeilBrown * @attrs: requested attributes of new object
159293adc1e3SNeilBrown * @resfhp: NFS filehandle of new object
159393adc1e3SNeilBrown *
15941da177e4SLinus Torvalds * N.B. After this call _both_ fhp and resfhp need an fh_put
159593adc1e3SNeilBrown *
159693adc1e3SNeilBrown * Returns nfs_ok on success, or an nfsstat in network byte order.
15971da177e4SLinus Torvalds */
15986264d69dSAl Viro __be32
nfsd_symlink(struct svc_rqst * rqstp,struct svc_fh * fhp,char * fname,int flen,char * path,struct nfsd_attrs * attrs,struct svc_fh * resfhp)15991da177e4SLinus Torvalds nfsd_symlink(struct svc_rqst *rqstp, struct svc_fh *fhp,
16001da177e4SLinus Torvalds char *fname, int flen,
160193adc1e3SNeilBrown char *path, struct nfsd_attrs *attrs,
16021e444f5bSKinglong Mee struct svc_fh *resfhp)
16031da177e4SLinus Torvalds {
16041da177e4SLinus Torvalds struct dentry *dentry, *dnew;
16056264d69dSAl Viro __be32 err, cerr;
16066264d69dSAl Viro int host_err;
16071da177e4SLinus Torvalds
16081da177e4SLinus Torvalds err = nfserr_noent;
160952ee0433SJ. Bruce Fields if (!flen || path[0] == '\0')
16101da177e4SLinus Torvalds goto out;
16111da177e4SLinus Torvalds err = nfserr_exist;
16121da177e4SLinus Torvalds if (isdotent(fname, flen))
16131da177e4SLinus Torvalds goto out;
16141da177e4SLinus Torvalds
16158837abcaSMiklos Szeredi err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE);
16161da177e4SLinus Torvalds if (err)
16171da177e4SLinus Torvalds goto out;
16184a55c101SJan Kara
16194a55c101SJan Kara host_err = fh_want_write(fhp);
1620927bfc56SNeilBrown if (host_err) {
1621927bfc56SNeilBrown err = nfserrno(host_err);
1622927bfc56SNeilBrown goto out;
1623927bfc56SNeilBrown }
16244a55c101SJan Kara
16251da177e4SLinus Torvalds dentry = fhp->fh_dentry;
1626debf16f0SNeilBrown inode_lock_nested(dentry->d_inode, I_MUTEX_PARENT);
16271da177e4SLinus Torvalds dnew = lookup_one_len(fname, dentry, flen);
1628927bfc56SNeilBrown if (IS_ERR(dnew)) {
1629927bfc56SNeilBrown err = nfserrno(PTR_ERR(dnew));
1630debf16f0SNeilBrown inode_unlock(dentry->d_inode);
1631927bfc56SNeilBrown goto out_drop_write;
1632927bfc56SNeilBrown }
1633a332018aSJeff Layton err = fh_fill_pre_attrs(fhp);
1634a332018aSJeff Layton if (err != nfs_ok)
1635a332018aSJeff Layton goto out_unlock;
1636abf08576SChristian Brauner host_err = vfs_symlink(&nop_mnt_idmap, d_inode(dentry), dnew, path);
16376264d69dSAl Viro err = nfserrno(host_err);
163893adc1e3SNeilBrown cerr = fh_compose(resfhp, fhp->fh_export, dnew, fhp);
163993adc1e3SNeilBrown if (!err)
164093adc1e3SNeilBrown nfsd_create_setattr(rqstp, fhp, resfhp, attrs);
1641debf16f0SNeilBrown fh_fill_post_attrs(fhp);
1642a332018aSJeff Layton out_unlock:
1643debf16f0SNeilBrown inode_unlock(dentry->d_inode);
1644f501912aSBen Myers if (!err)
1645f501912aSBen Myers err = nfserrno(commit_metadata(fhp));
16461da177e4SLinus Torvalds dput(dnew);
16471da177e4SLinus Torvalds if (err==0) err = cerr;
1648927bfc56SNeilBrown out_drop_write:
1649927bfc56SNeilBrown fh_drop_write(fhp);
16501da177e4SLinus Torvalds out:
16511da177e4SLinus Torvalds return err;
16521da177e4SLinus Torvalds }
16531da177e4SLinus Torvalds
16541da177e4SLinus Torvalds /*
16551da177e4SLinus Torvalds * Create a hardlink
16561da177e4SLinus Torvalds * N.B. After this call _both_ ffhp and tfhp need an fh_put
16571da177e4SLinus Torvalds */
16586264d69dSAl Viro __be32
nfsd_link(struct svc_rqst * rqstp,struct svc_fh * ffhp,char * name,int len,struct svc_fh * tfhp)16591da177e4SLinus Torvalds nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,
16601da177e4SLinus Torvalds char *name, int len, struct svc_fh *tfhp)
16611da177e4SLinus Torvalds {
16621da177e4SLinus Torvalds struct dentry *ddir, *dnew, *dold;
166355b13354SJ. Bruce Fields struct inode *dirp;
16646264d69dSAl Viro __be32 err;
16656264d69dSAl Viro int host_err;
16661da177e4SLinus Torvalds
16678837abcaSMiklos Szeredi err = fh_verify(rqstp, ffhp, S_IFDIR, NFSD_MAY_CREATE);
16681da177e4SLinus Torvalds if (err)
16691da177e4SLinus Torvalds goto out;
16707d818a7bSJ. Bruce Fields err = fh_verify(rqstp, tfhp, 0, NFSD_MAY_NOP);
16711da177e4SLinus Torvalds if (err)
16721da177e4SLinus Torvalds goto out;
16737d818a7bSJ. Bruce Fields err = nfserr_isdir;
1674e36cb0b8SDavid Howells if (d_is_dir(tfhp->fh_dentry))
16757d818a7bSJ. Bruce Fields goto out;
16761da177e4SLinus Torvalds err = nfserr_perm;
16771da177e4SLinus Torvalds if (!len)
16781da177e4SLinus Torvalds goto out;
16791da177e4SLinus Torvalds err = nfserr_exist;
16801da177e4SLinus Torvalds if (isdotent(name, len))
16811da177e4SLinus Torvalds goto out;
16821da177e4SLinus Torvalds
16834a55c101SJan Kara host_err = fh_want_write(tfhp);
16844a55c101SJan Kara if (host_err) {
16854a55c101SJan Kara err = nfserrno(host_err);
16864a55c101SJan Kara goto out;
16874a55c101SJan Kara }
16884a55c101SJan Kara
16891da177e4SLinus Torvalds ddir = ffhp->fh_dentry;
16902b0143b5SDavid Howells dirp = d_inode(ddir);
1691debf16f0SNeilBrown inode_lock_nested(dirp, I_MUTEX_PARENT);
16921da177e4SLinus Torvalds
16931da177e4SLinus Torvalds dnew = lookup_one_len(name, ddir, len);
1694e18bcb33SNeilBrown if (IS_ERR(dnew)) {
1695e18bcb33SNeilBrown err = nfserrno(PTR_ERR(dnew));
1696e18bcb33SNeilBrown goto out_unlock;
1697e18bcb33SNeilBrown }
16981da177e4SLinus Torvalds
16991da177e4SLinus Torvalds dold = tfhp->fh_dentry;
17001da177e4SLinus Torvalds
17014795bb37SJ. Bruce Fields err = nfserr_noent;
17022b0143b5SDavid Howells if (d_really_is_negative(dold))
17034a55c101SJan Kara goto out_dput;
1704a332018aSJeff Layton err = fh_fill_pre_attrs(ffhp);
1705a332018aSJeff Layton if (err != nfs_ok)
1706a332018aSJeff Layton goto out_dput;
1707abf08576SChristian Brauner host_err = vfs_link(dold, &nop_mnt_idmap, dirp, dnew, NULL);
1708debf16f0SNeilBrown fh_fill_post_attrs(ffhp);
1709debf16f0SNeilBrown inode_unlock(dirp);
17106264d69dSAl Viro if (!host_err) {
1711f501912aSBen Myers err = nfserrno(commit_metadata(ffhp));
1712f501912aSBen Myers if (!err)
1713f501912aSBen Myers err = nfserrno(commit_metadata(tfhp));
17141da177e4SLinus Torvalds } else {
17156264d69dSAl Viro if (host_err == -EXDEV && rqstp->rq_vers == 2)
17161da177e4SLinus Torvalds err = nfserr_acces;
17171da177e4SLinus Torvalds else
17186264d69dSAl Viro err = nfserrno(host_err);
17191da177e4SLinus Torvalds }
17201da177e4SLinus Torvalds dput(dnew);
1721e18bcb33SNeilBrown out_drop_write:
17224a55c101SJan Kara fh_drop_write(tfhp);
17231da177e4SLinus Torvalds out:
17241da177e4SLinus Torvalds return err;
17251da177e4SLinus Torvalds
1726e18bcb33SNeilBrown out_dput:
1727e18bcb33SNeilBrown dput(dnew);
1728e18bcb33SNeilBrown out_unlock:
1729debf16f0SNeilBrown inode_unlock(dirp);
1730e18bcb33SNeilBrown goto out_drop_write;
17311da177e4SLinus Torvalds }
17321da177e4SLinus Torvalds
17337775ec57SJeff Layton static void
nfsd_close_cached_files(struct dentry * dentry)17347775ec57SJeff Layton nfsd_close_cached_files(struct dentry *dentry)
17357775ec57SJeff Layton {
17367775ec57SJeff Layton struct inode *inode = d_inode(dentry);
17377775ec57SJeff Layton
17387775ec57SJeff Layton if (inode && S_ISREG(inode->i_mode))
17397775ec57SJeff Layton nfsd_file_close_inode_sync(inode);
17407775ec57SJeff Layton }
17417775ec57SJeff Layton
17427775ec57SJeff Layton static bool
nfsd_has_cached_files(struct dentry * dentry)17437775ec57SJeff Layton nfsd_has_cached_files(struct dentry *dentry)
17447775ec57SJeff Layton {
17457775ec57SJeff Layton bool ret = false;
17467775ec57SJeff Layton struct inode *inode = d_inode(dentry);
17477775ec57SJeff Layton
17487775ec57SJeff Layton if (inode && S_ISREG(inode->i_mode))
17497775ec57SJeff Layton ret = nfsd_file_is_cached(inode);
17507775ec57SJeff Layton return ret;
17517775ec57SJeff Layton }
17527775ec57SJeff Layton
17531da177e4SLinus Torvalds /*
17541da177e4SLinus Torvalds * Rename a file
17551da177e4SLinus Torvalds * N.B. After this call _both_ ffhp and tfhp need an fh_put
17561da177e4SLinus Torvalds */
17576264d69dSAl Viro __be32
nfsd_rename(struct svc_rqst * rqstp,struct svc_fh * ffhp,char * fname,int flen,struct svc_fh * tfhp,char * tname,int tlen)17581da177e4SLinus Torvalds nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen,
17591da177e4SLinus Torvalds struct svc_fh *tfhp, char *tname, int tlen)
17601da177e4SLinus Torvalds {
17611da177e4SLinus Torvalds struct dentry *fdentry, *tdentry, *odentry, *ndentry, *trap;
17621da177e4SLinus Torvalds struct inode *fdir, *tdir;
17636264d69dSAl Viro __be32 err;
17646264d69dSAl Viro int host_err;
17657f84b488SJeff Layton bool close_cached = false;
17661da177e4SLinus Torvalds
17678837abcaSMiklos Szeredi err = fh_verify(rqstp, ffhp, S_IFDIR, NFSD_MAY_REMOVE);
17681da177e4SLinus Torvalds if (err)
17691da177e4SLinus Torvalds goto out;
17708837abcaSMiklos Szeredi err = fh_verify(rqstp, tfhp, S_IFDIR, NFSD_MAY_CREATE);
17711da177e4SLinus Torvalds if (err)
17721da177e4SLinus Torvalds goto out;
17731da177e4SLinus Torvalds
17741da177e4SLinus Torvalds fdentry = ffhp->fh_dentry;
17752b0143b5SDavid Howells fdir = d_inode(fdentry);
17761da177e4SLinus Torvalds
17771da177e4SLinus Torvalds tdentry = tfhp->fh_dentry;
17782b0143b5SDavid Howells tdir = d_inode(tdentry);
17791da177e4SLinus Torvalds
17801da177e4SLinus Torvalds err = nfserr_perm;
17811da177e4SLinus Torvalds if (!flen || isdotent(fname, flen) || !tlen || isdotent(tname, tlen))
17821da177e4SLinus Torvalds goto out;
17831da177e4SLinus Torvalds
17841aee9158SAl Viro err = (rqstp->rq_vers == 2) ? nfserr_acces : nfserr_xdev;
17851aee9158SAl Viro if (ffhp->fh_export->ex_path.mnt != tfhp->fh_export->ex_path.mnt)
17861aee9158SAl Viro goto out;
17871aee9158SAl Viro if (ffhp->fh_export->ex_path.dentry != tfhp->fh_export->ex_path.dentry)
17881aee9158SAl Viro goto out;
17891aee9158SAl Viro
17907775ec57SJeff Layton retry:
17914a55c101SJan Kara host_err = fh_want_write(ffhp);
17924a55c101SJan Kara if (host_err) {
17934a55c101SJan Kara err = nfserrno(host_err);
17944a55c101SJan Kara goto out;
17954a55c101SJan Kara }
17964a55c101SJan Kara
17971da177e4SLinus Torvalds trap = lock_rename(tdentry, fdentry);
1798a332018aSJeff Layton err = fh_fill_pre_attrs(ffhp);
1799a332018aSJeff Layton if (err != nfs_ok)
1800a332018aSJeff Layton goto out_unlock;
1801a332018aSJeff Layton err = fh_fill_pre_attrs(tfhp);
1802a332018aSJeff Layton if (err != nfs_ok)
1803a332018aSJeff Layton goto out_unlock;
18041da177e4SLinus Torvalds
18051da177e4SLinus Torvalds odentry = lookup_one_len(fname, fdentry, flen);
18066264d69dSAl Viro host_err = PTR_ERR(odentry);
18071da177e4SLinus Torvalds if (IS_ERR(odentry))
18081da177e4SLinus Torvalds goto out_nfserr;
18091da177e4SLinus Torvalds
18106264d69dSAl Viro host_err = -ENOENT;
18112b0143b5SDavid Howells if (d_really_is_negative(odentry))
18121da177e4SLinus Torvalds goto out_dput_old;
18136264d69dSAl Viro host_err = -EINVAL;
18141da177e4SLinus Torvalds if (odentry == trap)
18151da177e4SLinus Torvalds goto out_dput_old;
18161da177e4SLinus Torvalds
18171da177e4SLinus Torvalds ndentry = lookup_one_len(tname, tdentry, tlen);
18186264d69dSAl Viro host_err = PTR_ERR(ndentry);
18191da177e4SLinus Torvalds if (IS_ERR(ndentry))
18201da177e4SLinus Torvalds goto out_dput_old;
18216264d69dSAl Viro host_err = -ENOTEMPTY;
18221da177e4SLinus Torvalds if (ndentry == trap)
18231da177e4SLinus Torvalds goto out_dput_new;
18241da177e4SLinus Torvalds
18257f84b488SJeff Layton if ((ndentry->d_sb->s_export_op->flags & EXPORT_OP_CLOSE_BEFORE_UNLINK) &&
18267f84b488SJeff Layton nfsd_has_cached_files(ndentry)) {
18277f84b488SJeff Layton close_cached = true;
18287775ec57SJeff Layton goto out_dput_old;
18297775ec57SJeff Layton } else {
18309fe61450SChristian Brauner struct renamedata rd = {
1831abf08576SChristian Brauner .old_mnt_idmap = &nop_mnt_idmap,
18329fe61450SChristian Brauner .old_dir = fdir,
18339fe61450SChristian Brauner .old_dentry = odentry,
1834abf08576SChristian Brauner .new_mnt_idmap = &nop_mnt_idmap,
18359fe61450SChristian Brauner .new_dir = tdir,
18369fe61450SChristian Brauner .new_dentry = ndentry,
18379fe61450SChristian Brauner };
183868c522afSChuck Lever int retries;
183968c522afSChuck Lever
184068c522afSChuck Lever for (retries = 1;;) {
18419fe61450SChristian Brauner host_err = vfs_rename(&rd);
184268c522afSChuck Lever if (host_err != -EAGAIN || !retries--)
184368c522afSChuck Lever break;
184468c522afSChuck Lever if (!nfsd_wait_for_delegreturn(rqstp, d_inode(odentry)))
184568c522afSChuck Lever break;
184668c522afSChuck Lever }
1847f501912aSBen Myers if (!host_err) {
1848f501912aSBen Myers host_err = commit_metadata(tfhp);
18496264d69dSAl Viro if (!host_err)
1850f501912aSBen Myers host_err = commit_metadata(ffhp);
18511da177e4SLinus Torvalds }
18527775ec57SJeff Layton }
18531da177e4SLinus Torvalds out_dput_new:
18541da177e4SLinus Torvalds dput(ndentry);
18551da177e4SLinus Torvalds out_dput_old:
18561da177e4SLinus Torvalds dput(odentry);
18571da177e4SLinus Torvalds out_nfserr:
18586264d69dSAl Viro err = nfserrno(host_err);
1859dd8dd403SNeilBrown
18607f84b488SJeff Layton if (!close_cached) {
1861fcb5e3faSChuck Lever fh_fill_post_attrs(ffhp);
1862fcb5e3faSChuck Lever fh_fill_post_attrs(tfhp);
18637775ec57SJeff Layton }
1864a332018aSJeff Layton out_unlock:
18651da177e4SLinus Torvalds unlock_rename(tdentry, fdentry);
18664a55c101SJan Kara fh_drop_write(ffhp);
18671da177e4SLinus Torvalds
18687775ec57SJeff Layton /*
18697775ec57SJeff Layton * If the target dentry has cached open files, then we need to try to
18707775ec57SJeff Layton * close them prior to doing the rename. Flushing delayed fput
18717775ec57SJeff Layton * shouldn't be done with locks held however, so we delay it until this
18727775ec57SJeff Layton * point and then reattempt the whole shebang.
18737775ec57SJeff Layton */
18747f84b488SJeff Layton if (close_cached) {
18757f84b488SJeff Layton close_cached = false;
18767775ec57SJeff Layton nfsd_close_cached_files(ndentry);
18777775ec57SJeff Layton dput(ndentry);
18787775ec57SJeff Layton goto retry;
18797775ec57SJeff Layton }
18801da177e4SLinus Torvalds out:
18811da177e4SLinus Torvalds return err;
18821da177e4SLinus Torvalds }
18831da177e4SLinus Torvalds
18841da177e4SLinus Torvalds /*
18851da177e4SLinus Torvalds * Unlink a file or directory
18861da177e4SLinus Torvalds * N.B. After this call fhp needs an fh_put
18871da177e4SLinus Torvalds */
18886264d69dSAl Viro __be32
nfsd_unlink(struct svc_rqst * rqstp,struct svc_fh * fhp,int type,char * fname,int flen)18891da177e4SLinus Torvalds nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
18901da177e4SLinus Torvalds char *fname, int flen)
18911da177e4SLinus Torvalds {
18921da177e4SLinus Torvalds struct dentry *dentry, *rdentry;
18931da177e4SLinus Torvalds struct inode *dirp;
1894e5d74a2dSYu Hsiang Huang struct inode *rinode;
18956264d69dSAl Viro __be32 err;
18966264d69dSAl Viro int host_err;
18971da177e4SLinus Torvalds
18981da177e4SLinus Torvalds err = nfserr_acces;
18991da177e4SLinus Torvalds if (!flen || isdotent(fname, flen))
19001da177e4SLinus Torvalds goto out;
19018837abcaSMiklos Szeredi err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_REMOVE);
19021da177e4SLinus Torvalds if (err)
19031da177e4SLinus Torvalds goto out;
19041da177e4SLinus Torvalds
19054a55c101SJan Kara host_err = fh_want_write(fhp);
19064a55c101SJan Kara if (host_err)
19074a55c101SJan Kara goto out_nfserr;
19084a55c101SJan Kara
19091da177e4SLinus Torvalds dentry = fhp->fh_dentry;
19102b0143b5SDavid Howells dirp = d_inode(dentry);
1911debf16f0SNeilBrown inode_lock_nested(dirp, I_MUTEX_PARENT);
19121da177e4SLinus Torvalds
19131da177e4SLinus Torvalds rdentry = lookup_one_len(fname, dentry, flen);
19146264d69dSAl Viro host_err = PTR_ERR(rdentry);
19151da177e4SLinus Torvalds if (IS_ERR(rdentry))
1916b677c0c6SNeilBrown goto out_unlock;
19171da177e4SLinus Torvalds
19182b0143b5SDavid Howells if (d_really_is_negative(rdentry)) {
19191da177e4SLinus Torvalds dput(rdentry);
19200ca0c9d7SJ. Bruce Fields host_err = -ENOENT;
1921b677c0c6SNeilBrown goto out_unlock;
19221da177e4SLinus Torvalds }
1923e5d74a2dSYu Hsiang Huang rinode = d_inode(rdentry);
1924a332018aSJeff Layton err = fh_fill_pre_attrs(fhp);
1925a332018aSJeff Layton if (err != nfs_ok)
1926a332018aSJeff Layton goto out_unlock;
19271da177e4SLinus Torvalds
1928a332018aSJeff Layton ihold(rinode);
19291da177e4SLinus Torvalds if (!type)
19302b0143b5SDavid Howells type = d_inode(rdentry)->i_mode & S_IFMT;
19311da177e4SLinus Torvalds
19327775ec57SJeff Layton if (type != S_IFDIR) {
19335f5f8b6dSChuck Lever int retries;
19345f5f8b6dSChuck Lever
19357f84b488SJeff Layton if (rdentry->d_sb->s_export_op->flags & EXPORT_OP_CLOSE_BEFORE_UNLINK)
19367775ec57SJeff Layton nfsd_close_cached_files(rdentry);
19375f5f8b6dSChuck Lever
19385f5f8b6dSChuck Lever for (retries = 1;;) {
1939abf08576SChristian Brauner host_err = vfs_unlink(&nop_mnt_idmap, dirp, rdentry, NULL);
19405f5f8b6dSChuck Lever if (host_err != -EAGAIN || !retries--)
19415f5f8b6dSChuck Lever break;
19425f5f8b6dSChuck Lever if (!nfsd_wait_for_delegreturn(rqstp, rinode))
19435f5f8b6dSChuck Lever break;
19445f5f8b6dSChuck Lever }
19457775ec57SJeff Layton } else {
1946abf08576SChristian Brauner host_err = vfs_rmdir(&nop_mnt_idmap, dirp, rdentry);
19477775ec57SJeff Layton }
1948debf16f0SNeilBrown fh_fill_post_attrs(fhp);
19497775ec57SJeff Layton
1950debf16f0SNeilBrown inode_unlock(dirp);
1951541ce98cSJ. Bruce Fields if (!host_err)
1952541ce98cSJ. Bruce Fields host_err = commit_metadata(fhp);
19531da177e4SLinus Torvalds dput(rdentry);
1954e5d74a2dSYu Hsiang Huang iput(rinode); /* truncate the inode here */
19551da177e4SLinus Torvalds
19560ca0c9d7SJ. Bruce Fields out_drop_write:
19570ca0c9d7SJ. Bruce Fields fh_drop_write(fhp);
19581da177e4SLinus Torvalds out_nfserr:
1959466e16f0SNeilBrown if (host_err == -EBUSY) {
1960466e16f0SNeilBrown /* name is mounted-on. There is no perfect
1961466e16f0SNeilBrown * error status.
1962466e16f0SNeilBrown */
1963466e16f0SNeilBrown if (nfsd_v4client(rqstp))
1964466e16f0SNeilBrown err = nfserr_file_open;
1965466e16f0SNeilBrown else
1966466e16f0SNeilBrown err = nfserr_acces;
1967466e16f0SNeilBrown } else {
19686264d69dSAl Viro err = nfserrno(host_err);
1969466e16f0SNeilBrown }
1970f193fbabSYAMAMOTO Takashi out:
1971f193fbabSYAMAMOTO Takashi return err;
1972b677c0c6SNeilBrown out_unlock:
1973debf16f0SNeilBrown inode_unlock(dirp);
1974b677c0c6SNeilBrown goto out_drop_write;
19751da177e4SLinus Torvalds }
19761da177e4SLinus Torvalds
19771da177e4SLinus Torvalds /*
197814f7dd63SDavid Woodhouse * We do this buffering because we must not call back into the file
197914f7dd63SDavid Woodhouse * system's ->lookup() method from the filldir callback. That may well
198014f7dd63SDavid Woodhouse * deadlock a number of file systems.
198114f7dd63SDavid Woodhouse *
198214f7dd63SDavid Woodhouse * This is based heavily on the implementation of same in XFS.
198314f7dd63SDavid Woodhouse */
198414f7dd63SDavid Woodhouse struct buffered_dirent {
198514f7dd63SDavid Woodhouse u64 ino;
198614f7dd63SDavid Woodhouse loff_t offset;
198714f7dd63SDavid Woodhouse int namlen;
198814f7dd63SDavid Woodhouse unsigned int d_type;
198914f7dd63SDavid Woodhouse char name[];
199014f7dd63SDavid Woodhouse };
199114f7dd63SDavid Woodhouse
199214f7dd63SDavid Woodhouse struct readdir_data {
19935c0ba4e0SAl Viro struct dir_context ctx;
199414f7dd63SDavid Woodhouse char *dirent;
199514f7dd63SDavid Woodhouse size_t used;
199653c9c5c0SAl Viro int full;
199714f7dd63SDavid Woodhouse };
199814f7dd63SDavid Woodhouse
nfsd_buffered_filldir(struct dir_context * ctx,const char * name,int namlen,loff_t offset,u64 ino,unsigned int d_type)199925885a35SAl Viro static bool nfsd_buffered_filldir(struct dir_context *ctx, const char *name,
2000ac7576f4SMiklos Szeredi int namlen, loff_t offset, u64 ino,
2001ac7576f4SMiklos Szeredi unsigned int d_type)
200214f7dd63SDavid Woodhouse {
2003ac7576f4SMiklos Szeredi struct readdir_data *buf =
2004ac7576f4SMiklos Szeredi container_of(ctx, struct readdir_data, ctx);
200514f7dd63SDavid Woodhouse struct buffered_dirent *de = (void *)(buf->dirent + buf->used);
200614f7dd63SDavid Woodhouse unsigned int reclen;
200714f7dd63SDavid Woodhouse
200814f7dd63SDavid Woodhouse reclen = ALIGN(sizeof(struct buffered_dirent) + namlen, sizeof(u64));
200953c9c5c0SAl Viro if (buf->used + reclen > PAGE_SIZE) {
201053c9c5c0SAl Viro buf->full = 1;
201125885a35SAl Viro return false;
201253c9c5c0SAl Viro }
201314f7dd63SDavid Woodhouse
201414f7dd63SDavid Woodhouse de->namlen = namlen;
201514f7dd63SDavid Woodhouse de->offset = offset;
201614f7dd63SDavid Woodhouse de->ino = ino;
201714f7dd63SDavid Woodhouse de->d_type = d_type;
201814f7dd63SDavid Woodhouse memcpy(de->name, name, namlen);
201914f7dd63SDavid Woodhouse buf->used += reclen;
202014f7dd63SDavid Woodhouse
202125885a35SAl Viro return true;
202214f7dd63SDavid Woodhouse }
202314f7dd63SDavid Woodhouse
nfsd_buffered_readdir(struct file * file,struct svc_fh * fhp,nfsd_filldir_t func,struct readdir_cd * cdp,loff_t * offsetp)20246019ce07SChuck Lever static __be32 nfsd_buffered_readdir(struct file *file, struct svc_fh *fhp,
20256019ce07SChuck Lever nfsd_filldir_t func, struct readdir_cd *cdp,
20266019ce07SChuck Lever loff_t *offsetp)
20272628b766SDavid Woodhouse {
202814f7dd63SDavid Woodhouse struct buffered_dirent *de;
20292628b766SDavid Woodhouse int host_err;
203014f7dd63SDavid Woodhouse int size;
203114f7dd63SDavid Woodhouse loff_t offset;
2032ac6614b7SAl Viro struct readdir_data buf = {
2033ac6614b7SAl Viro .ctx.actor = nfsd_buffered_filldir,
2034ac6614b7SAl Viro .dirent = (void *)__get_free_page(GFP_KERNEL)
2035ac6614b7SAl Viro };
20362628b766SDavid Woodhouse
203714f7dd63SDavid Woodhouse if (!buf.dirent)
20382f9092e1SDavid Woodhouse return nfserrno(-ENOMEM);
203914f7dd63SDavid Woodhouse
204014f7dd63SDavid Woodhouse offset = *offsetp;
20412628b766SDavid Woodhouse
204214f7dd63SDavid Woodhouse while (1) {
204314f7dd63SDavid Woodhouse unsigned int reclen;
204414f7dd63SDavid Woodhouse
2045b726e923SDoug Nazar cdp->err = nfserr_eof; /* will be cleared on successful read */
204614f7dd63SDavid Woodhouse buf.used = 0;
204753c9c5c0SAl Viro buf.full = 0;
204814f7dd63SDavid Woodhouse
20495c0ba4e0SAl Viro host_err = iterate_dir(file, &buf.ctx);
205053c9c5c0SAl Viro if (buf.full)
205153c9c5c0SAl Viro host_err = 0;
205253c9c5c0SAl Viro
205353c9c5c0SAl Viro if (host_err < 0)
205414f7dd63SDavid Woodhouse break;
205514f7dd63SDavid Woodhouse
205614f7dd63SDavid Woodhouse size = buf.used;
205714f7dd63SDavid Woodhouse
205814f7dd63SDavid Woodhouse if (!size)
205914f7dd63SDavid Woodhouse break;
206014f7dd63SDavid Woodhouse
206114f7dd63SDavid Woodhouse de = (struct buffered_dirent *)buf.dirent;
206214f7dd63SDavid Woodhouse while (size > 0) {
206314f7dd63SDavid Woodhouse offset = de->offset;
206414f7dd63SDavid Woodhouse
206514f7dd63SDavid Woodhouse if (func(cdp, de->name, de->namlen, de->offset,
206614f7dd63SDavid Woodhouse de->ino, de->d_type))
20672f9092e1SDavid Woodhouse break;
206814f7dd63SDavid Woodhouse
206914f7dd63SDavid Woodhouse if (cdp->err != nfs_ok)
20702f9092e1SDavid Woodhouse break;
207114f7dd63SDavid Woodhouse
20726019ce07SChuck Lever trace_nfsd_dirent(fhp, de->ino, de->name, de->namlen);
20736019ce07SChuck Lever
207414f7dd63SDavid Woodhouse reclen = ALIGN(sizeof(*de) + de->namlen,
207514f7dd63SDavid Woodhouse sizeof(u64));
207614f7dd63SDavid Woodhouse size -= reclen;
207714f7dd63SDavid Woodhouse de = (struct buffered_dirent *)((char *)de + reclen);
207814f7dd63SDavid Woodhouse }
20792f9092e1SDavid Woodhouse if (size > 0) /* We bailed out early */
20802f9092e1SDavid Woodhouse break;
20812f9092e1SDavid Woodhouse
2082c002a6c7SDavid Woodhouse offset = vfs_llseek(file, 0, SEEK_CUR);
208314f7dd63SDavid Woodhouse }
208414f7dd63SDavid Woodhouse
208514f7dd63SDavid Woodhouse free_page((unsigned long)(buf.dirent));
20862628b766SDavid Woodhouse
20872628b766SDavid Woodhouse if (host_err)
20882628b766SDavid Woodhouse return nfserrno(host_err);
208914f7dd63SDavid Woodhouse
209014f7dd63SDavid Woodhouse *offsetp = offset;
20912628b766SDavid Woodhouse return cdp->err;
20922628b766SDavid Woodhouse }
20932628b766SDavid Woodhouse
20941da177e4SLinus Torvalds /*
20951da177e4SLinus Torvalds * Read entries from a directory.
20961da177e4SLinus Torvalds * The NFSv3/4 verifier we ignore for now.
20971da177e4SLinus Torvalds */
20986264d69dSAl Viro __be32
nfsd_readdir(struct svc_rqst * rqstp,struct svc_fh * fhp,loff_t * offsetp,struct readdir_cd * cdp,nfsd_filldir_t func)20991da177e4SLinus Torvalds nfsd_readdir(struct svc_rqst *rqstp, struct svc_fh *fhp, loff_t *offsetp,
2100ac7576f4SMiklos Szeredi struct readdir_cd *cdp, nfsd_filldir_t func)
21011da177e4SLinus Torvalds {
21026264d69dSAl Viro __be32 err;
21031da177e4SLinus Torvalds struct file *file;
21041da177e4SLinus Torvalds loff_t offset = *offsetp;
210506effdbbSBernd Schubert int may_flags = NFSD_MAY_READ;
21061da177e4SLinus Torvalds
210706effdbbSBernd Schubert /* NFSv2 only supports 32 bit cookies */
210806effdbbSBernd Schubert if (rqstp->rq_vers > 2)
210906effdbbSBernd Schubert may_flags |= NFSD_MAY_64BIT_COOKIE;
211006effdbbSBernd Schubert
211106effdbbSBernd Schubert err = nfsd_open(rqstp, fhp, S_IFDIR, may_flags, &file);
21121da177e4SLinus Torvalds if (err)
21131da177e4SLinus Torvalds goto out;
21141da177e4SLinus Torvalds
2115b108fe6bSJeff Layton offset = vfs_llseek(file, offset, SEEK_SET);
21161da177e4SLinus Torvalds if (offset < 0) {
21171da177e4SLinus Torvalds err = nfserrno((int)offset);
21181da177e4SLinus Torvalds goto out_close;
21191da177e4SLinus Torvalds }
21201da177e4SLinus Torvalds
21216019ce07SChuck Lever err = nfsd_buffered_readdir(file, fhp, func, cdp, offsetp);
21221da177e4SLinus Torvalds
21231da177e4SLinus Torvalds if (err == nfserr_eof || err == nfserr_toosmall)
21241da177e4SLinus Torvalds err = nfs_ok; /* can still be found in ->err */
21251da177e4SLinus Torvalds out_close:
2126fd891454SChristoph Hellwig fput(file);
21271da177e4SLinus Torvalds out:
21281da177e4SLinus Torvalds return err;
21291da177e4SLinus Torvalds }
21301da177e4SLinus Torvalds
21311da177e4SLinus Torvalds /*
21321da177e4SLinus Torvalds * Get file system stats
21331da177e4SLinus Torvalds * N.B. After this call fhp needs an fh_put
21341da177e4SLinus Torvalds */
21356264d69dSAl Viro __be32
nfsd_statfs(struct svc_rqst * rqstp,struct svc_fh * fhp,struct kstatfs * stat,int access)213604716e66SJ. Bruce Fields nfsd_statfs(struct svc_rqst *rqstp, struct svc_fh *fhp, struct kstatfs *stat, int access)
21371da177e4SLinus Torvalds {
2138f6360efbSTakashi Iwai __be32 err;
2139f6360efbSTakashi Iwai
2140f6360efbSTakashi Iwai err = fh_verify(rqstp, fhp, 0, NFSD_MAY_NOP | access);
2141f6360efbSTakashi Iwai if (!err) {
2142ebabe9a9SChristoph Hellwig struct path path = {
2143ebabe9a9SChristoph Hellwig .mnt = fhp->fh_export->ex_path.mnt,
2144ebabe9a9SChristoph Hellwig .dentry = fhp->fh_dentry,
2145ebabe9a9SChristoph Hellwig };
2146f6360efbSTakashi Iwai if (vfs_statfs(&path, stat))
21471da177e4SLinus Torvalds err = nfserr_io;
2148f6360efbSTakashi Iwai }
21491da177e4SLinus Torvalds return err;
21501da177e4SLinus Torvalds }
21511da177e4SLinus Torvalds
exp_rdonly(struct svc_rqst * rqstp,struct svc_export * exp)2152c7d51402SJ. Bruce Fields static int exp_rdonly(struct svc_rqst *rqstp, struct svc_export *exp)
2153e22841c6SJ. Bruce Fields {
2154c7d51402SJ. Bruce Fields return nfsexp_flags(rqstp, exp) & NFSEXP_READONLY;
2155e22841c6SJ. Bruce Fields }
2156e22841c6SJ. Bruce Fields
215732119446SFrank van der Linden #ifdef CONFIG_NFSD_V4
215832119446SFrank van der Linden /*
215932119446SFrank van der Linden * Helper function to translate error numbers. In the case of xattr operations,
216032119446SFrank van der Linden * some error codes need to be translated outside of the standard translations.
216132119446SFrank van der Linden *
216232119446SFrank van der Linden * ENODATA needs to be translated to nfserr_noxattr.
216332119446SFrank van der Linden * E2BIG to nfserr_xattr2big.
216432119446SFrank van der Linden *
216532119446SFrank van der Linden * Additionally, vfs_listxattr can return -ERANGE. This means that the
216632119446SFrank van der Linden * file has too many extended attributes to retrieve inside an
216732119446SFrank van der Linden * XATTR_LIST_MAX sized buffer. This is a bug in the xattr implementation:
216832119446SFrank van der Linden * filesystems will allow the adding of extended attributes until they hit
216932119446SFrank van der Linden * their own internal limit. This limit may be larger than XATTR_LIST_MAX.
217032119446SFrank van der Linden * So, at that point, the attributes are present and valid, but can't
217132119446SFrank van der Linden * be retrieved using listxattr, since the upper level xattr code enforces
217232119446SFrank van der Linden * the XATTR_LIST_MAX limit.
217332119446SFrank van der Linden *
217432119446SFrank van der Linden * This bug means that we need to deal with listxattr returning -ERANGE. The
217532119446SFrank van der Linden * best mapping is to return TOOSMALL.
217632119446SFrank van der Linden */
217732119446SFrank van der Linden static __be32
nfsd_xattr_errno(int err)217832119446SFrank van der Linden nfsd_xattr_errno(int err)
217932119446SFrank van der Linden {
218032119446SFrank van der Linden switch (err) {
218132119446SFrank van der Linden case -ENODATA:
218232119446SFrank van der Linden return nfserr_noxattr;
218332119446SFrank van der Linden case -E2BIG:
218432119446SFrank van der Linden return nfserr_xattr2big;
218532119446SFrank van der Linden case -ERANGE:
218632119446SFrank van der Linden return nfserr_toosmall;
218732119446SFrank van der Linden }
218832119446SFrank van der Linden return nfserrno(err);
218932119446SFrank van der Linden }
219032119446SFrank van der Linden
219132119446SFrank van der Linden /*
219232119446SFrank van der Linden * Retrieve the specified user extended attribute. To avoid always
219332119446SFrank van der Linden * having to allocate the maximum size (since we are not getting
219432119446SFrank van der Linden * a maximum size from the RPC), do a probe + alloc. Hold a reader
219532119446SFrank van der Linden * lock on i_rwsem to prevent the extended attribute from changing
219632119446SFrank van der Linden * size while we're doing this.
219732119446SFrank van der Linden */
219832119446SFrank van der Linden __be32
nfsd_getxattr(struct svc_rqst * rqstp,struct svc_fh * fhp,char * name,void ** bufp,int * lenp)219932119446SFrank van der Linden nfsd_getxattr(struct svc_rqst *rqstp, struct svc_fh *fhp, char *name,
220032119446SFrank van der Linden void **bufp, int *lenp)
220132119446SFrank van der Linden {
220232119446SFrank van der Linden ssize_t len;
220332119446SFrank van der Linden __be32 err;
220432119446SFrank van der Linden char *buf;
220532119446SFrank van der Linden struct inode *inode;
220632119446SFrank van der Linden struct dentry *dentry;
220732119446SFrank van der Linden
220832119446SFrank van der Linden err = fh_verify(rqstp, fhp, 0, NFSD_MAY_READ);
220932119446SFrank van der Linden if (err)
221032119446SFrank van der Linden return err;
221132119446SFrank van der Linden
221232119446SFrank van der Linden err = nfs_ok;
221332119446SFrank van der Linden dentry = fhp->fh_dentry;
221432119446SFrank van der Linden inode = d_inode(dentry);
221532119446SFrank van der Linden
221632119446SFrank van der Linden inode_lock_shared(inode);
221732119446SFrank van der Linden
22184609e1f1SChristian Brauner len = vfs_getxattr(&nop_mnt_idmap, dentry, name, NULL, 0);
221932119446SFrank van der Linden
222032119446SFrank van der Linden /*
222132119446SFrank van der Linden * Zero-length attribute, just return.
222232119446SFrank van der Linden */
222332119446SFrank van der Linden if (len == 0) {
222432119446SFrank van der Linden *bufp = NULL;
222532119446SFrank van der Linden *lenp = 0;
222632119446SFrank van der Linden goto out;
222732119446SFrank van der Linden }
222832119446SFrank van der Linden
222932119446SFrank van der Linden if (len < 0) {
223032119446SFrank van der Linden err = nfsd_xattr_errno(len);
223132119446SFrank van der Linden goto out;
223232119446SFrank van der Linden }
223332119446SFrank van der Linden
223432119446SFrank van der Linden if (len > *lenp) {
223532119446SFrank van der Linden err = nfserr_toosmall;
223632119446SFrank van der Linden goto out;
223732119446SFrank van der Linden }
223832119446SFrank van der Linden
223922b620ecSChuck Lever buf = kvmalloc(len, GFP_KERNEL);
224032119446SFrank van der Linden if (buf == NULL) {
224132119446SFrank van der Linden err = nfserr_jukebox;
224232119446SFrank van der Linden goto out;
224332119446SFrank van der Linden }
224432119446SFrank van der Linden
22454609e1f1SChristian Brauner len = vfs_getxattr(&nop_mnt_idmap, dentry, name, buf, len);
224632119446SFrank van der Linden if (len <= 0) {
224732119446SFrank van der Linden kvfree(buf);
224832119446SFrank van der Linden buf = NULL;
224932119446SFrank van der Linden err = nfsd_xattr_errno(len);
225032119446SFrank van der Linden }
225132119446SFrank van der Linden
225232119446SFrank van der Linden *lenp = len;
225332119446SFrank van der Linden *bufp = buf;
225432119446SFrank van der Linden
225532119446SFrank van der Linden out:
225632119446SFrank van der Linden inode_unlock_shared(inode);
225732119446SFrank van der Linden
225832119446SFrank van der Linden return err;
225932119446SFrank van der Linden }
226032119446SFrank van der Linden
226132119446SFrank van der Linden /*
226232119446SFrank van der Linden * Retrieve the xattr names. Since we can't know how many are
226332119446SFrank van der Linden * user extended attributes, we must get all attributes here,
226432119446SFrank van der Linden * and have the XDR encode filter out the "user." ones.
226532119446SFrank van der Linden *
226632119446SFrank van der Linden * While this could always just allocate an XATTR_LIST_MAX
226732119446SFrank van der Linden * buffer, that's a waste, so do a probe + allocate. To
226832119446SFrank van der Linden * avoid any changes between the probe and allocate, wrap
226932119446SFrank van der Linden * this in inode_lock.
227032119446SFrank van der Linden */
227132119446SFrank van der Linden __be32
nfsd_listxattr(struct svc_rqst * rqstp,struct svc_fh * fhp,char ** bufp,int * lenp)227232119446SFrank van der Linden nfsd_listxattr(struct svc_rqst *rqstp, struct svc_fh *fhp, char **bufp,
227332119446SFrank van der Linden int *lenp)
227432119446SFrank van der Linden {
227532119446SFrank van der Linden ssize_t len;
227632119446SFrank van der Linden __be32 err;
227732119446SFrank van der Linden char *buf;
227832119446SFrank van der Linden struct inode *inode;
227932119446SFrank van der Linden struct dentry *dentry;
228032119446SFrank van der Linden
228132119446SFrank van der Linden err = fh_verify(rqstp, fhp, 0, NFSD_MAY_READ);
228232119446SFrank van der Linden if (err)
228332119446SFrank van der Linden return err;
228432119446SFrank van der Linden
228532119446SFrank van der Linden dentry = fhp->fh_dentry;
228632119446SFrank van der Linden inode = d_inode(dentry);
228732119446SFrank van der Linden *lenp = 0;
228832119446SFrank van der Linden
228932119446SFrank van der Linden inode_lock_shared(inode);
229032119446SFrank van der Linden
229132119446SFrank van der Linden len = vfs_listxattr(dentry, NULL, 0);
229232119446SFrank van der Linden if (len <= 0) {
229332119446SFrank van der Linden err = nfsd_xattr_errno(len);
229432119446SFrank van der Linden goto out;
229532119446SFrank van der Linden }
229632119446SFrank van der Linden
229732119446SFrank van der Linden if (len > XATTR_LIST_MAX) {
229832119446SFrank van der Linden err = nfserr_xattr2big;
229932119446SFrank van der Linden goto out;
230032119446SFrank van der Linden }
230132119446SFrank van der Linden
230222b620ecSChuck Lever buf = kvmalloc(len, GFP_KERNEL);
230332119446SFrank van der Linden if (buf == NULL) {
230432119446SFrank van der Linden err = nfserr_jukebox;
230532119446SFrank van der Linden goto out;
230632119446SFrank van der Linden }
230732119446SFrank van der Linden
230832119446SFrank van der Linden len = vfs_listxattr(dentry, buf, len);
230932119446SFrank van der Linden if (len <= 0) {
231032119446SFrank van der Linden kvfree(buf);
231132119446SFrank van der Linden err = nfsd_xattr_errno(len);
231232119446SFrank van der Linden goto out;
231332119446SFrank van der Linden }
231432119446SFrank van der Linden
231532119446SFrank van der Linden *lenp = len;
231632119446SFrank van der Linden *bufp = buf;
231732119446SFrank van der Linden
231832119446SFrank van der Linden err = nfs_ok;
231932119446SFrank van der Linden out:
232032119446SFrank van der Linden inode_unlock_shared(inode);
232132119446SFrank van der Linden
232232119446SFrank van der Linden return err;
232332119446SFrank van der Linden }
232432119446SFrank van der Linden
2325bb4d53d6SNeilBrown /**
2326bb4d53d6SNeilBrown * nfsd_removexattr - Remove an extended attribute
2327bb4d53d6SNeilBrown * @rqstp: RPC transaction being executed
2328bb4d53d6SNeilBrown * @fhp: NFS filehandle of object with xattr to remove
2329bb4d53d6SNeilBrown * @name: name of xattr to remove (NUL-terminate)
2330bb4d53d6SNeilBrown *
2331bb4d53d6SNeilBrown * Pass in a NULL pointer for delegated_inode, and let the client deal
2332bb4d53d6SNeilBrown * with NFS4ERR_DELAY (same as with e.g. setattr and remove).
2333bb4d53d6SNeilBrown *
2334bb4d53d6SNeilBrown * Returns nfs_ok on success, or an nfsstat in network byte order.
233532119446SFrank van der Linden */
233632119446SFrank van der Linden __be32
nfsd_removexattr(struct svc_rqst * rqstp,struct svc_fh * fhp,char * name)233732119446SFrank van der Linden nfsd_removexattr(struct svc_rqst *rqstp, struct svc_fh *fhp, char *name)
233832119446SFrank van der Linden {
23398237284aSChuck Lever __be32 err;
23408237284aSChuck Lever int ret;
234132119446SFrank van der Linden
234232119446SFrank van der Linden err = fh_verify(rqstp, fhp, 0, NFSD_MAY_WRITE);
234332119446SFrank van der Linden if (err)
234432119446SFrank van der Linden return err;
234532119446SFrank van der Linden
234632119446SFrank van der Linden ret = fh_want_write(fhp);
234732119446SFrank van der Linden if (ret)
234832119446SFrank van der Linden return nfserrno(ret);
234932119446SFrank van der Linden
2350bb4d53d6SNeilBrown inode_lock(fhp->fh_dentry->d_inode);
2351a332018aSJeff Layton err = fh_fill_pre_attrs(fhp);
2352a332018aSJeff Layton if (err != nfs_ok)
2353a332018aSJeff Layton goto out_unlock;
23544609e1f1SChristian Brauner ret = __vfs_removexattr_locked(&nop_mnt_idmap, fhp->fh_dentry,
2355c7c7a1a1STycho Andersen name, NULL);
2356a332018aSJeff Layton err = nfsd_xattr_errno(ret);
2357bb4d53d6SNeilBrown fh_fill_post_attrs(fhp);
2358a332018aSJeff Layton out_unlock:
2359bb4d53d6SNeilBrown inode_unlock(fhp->fh_dentry->d_inode);
236032119446SFrank van der Linden fh_drop_write(fhp);
236132119446SFrank van der Linden
2362a332018aSJeff Layton return err;
236332119446SFrank van der Linden }
236432119446SFrank van der Linden
236532119446SFrank van der Linden __be32
nfsd_setxattr(struct svc_rqst * rqstp,struct svc_fh * fhp,char * name,void * buf,u32 len,u32 flags)236632119446SFrank van der Linden nfsd_setxattr(struct svc_rqst *rqstp, struct svc_fh *fhp, char *name,
236732119446SFrank van der Linden void *buf, u32 len, u32 flags)
236832119446SFrank van der Linden {
23698237284aSChuck Lever __be32 err;
23708237284aSChuck Lever int ret;
237132119446SFrank van der Linden
237232119446SFrank van der Linden err = fh_verify(rqstp, fhp, 0, NFSD_MAY_WRITE);
237332119446SFrank van der Linden if (err)
237432119446SFrank van der Linden return err;
237532119446SFrank van der Linden
237632119446SFrank van der Linden ret = fh_want_write(fhp);
237732119446SFrank van der Linden if (ret)
237832119446SFrank van der Linden return nfserrno(ret);
2379bb4d53d6SNeilBrown inode_lock(fhp->fh_dentry->d_inode);
2380a332018aSJeff Layton err = fh_fill_pre_attrs(fhp);
2381a332018aSJeff Layton if (err != nfs_ok)
2382a332018aSJeff Layton goto out_unlock;
2383a332018aSJeff Layton ret = __vfs_setxattr_locked(&nop_mnt_idmap, fhp->fh_dentry,
2384a332018aSJeff Layton name, buf, len, flags, NULL);
2385bb4d53d6SNeilBrown fh_fill_post_attrs(fhp);
2386a332018aSJeff Layton err = nfsd_xattr_errno(ret);
2387a332018aSJeff Layton out_unlock:
2388bb4d53d6SNeilBrown inode_unlock(fhp->fh_dentry->d_inode);
238932119446SFrank van der Linden fh_drop_write(fhp);
2390a332018aSJeff Layton return err;
239132119446SFrank van der Linden }
239232119446SFrank van der Linden #endif
239332119446SFrank van der Linden
23941da177e4SLinus Torvalds /*
23951da177e4SLinus Torvalds * Check for a user's access permissions to this inode.
23961da177e4SLinus Torvalds */
23976264d69dSAl Viro __be32
nfsd_permission(struct svc_rqst * rqstp,struct svc_export * exp,struct dentry * dentry,int acc)23980ec757dfSJ. Bruce Fields nfsd_permission(struct svc_rqst *rqstp, struct svc_export *exp,
23990ec757dfSJ. Bruce Fields struct dentry *dentry, int acc)
24001da177e4SLinus Torvalds {
24012b0143b5SDavid Howells struct inode *inode = d_inode(dentry);
24021da177e4SLinus Torvalds int err;
24031da177e4SLinus Torvalds
2404aea93397SJ. Bruce Fields if ((acc & NFSD_MAY_MASK) == NFSD_MAY_NOP)
24051da177e4SLinus Torvalds return 0;
24061da177e4SLinus Torvalds #if 0
24071da177e4SLinus Torvalds dprintk("nfsd: permission 0x%x%s%s%s%s%s%s%s mode 0%o%s%s%s\n",
24081da177e4SLinus Torvalds acc,
24098837abcaSMiklos Szeredi (acc & NFSD_MAY_READ)? " read" : "",
24108837abcaSMiklos Szeredi (acc & NFSD_MAY_WRITE)? " write" : "",
24118837abcaSMiklos Szeredi (acc & NFSD_MAY_EXEC)? " exec" : "",
24128837abcaSMiklos Szeredi (acc & NFSD_MAY_SATTR)? " sattr" : "",
24138837abcaSMiklos Szeredi (acc & NFSD_MAY_TRUNC)? " trunc" : "",
24148837abcaSMiklos Szeredi (acc & NFSD_MAY_LOCK)? " lock" : "",
24158837abcaSMiklos Szeredi (acc & NFSD_MAY_OWNER_OVERRIDE)? " owneroverride" : "",
24161da177e4SLinus Torvalds inode->i_mode,
24171da177e4SLinus Torvalds IS_IMMUTABLE(inode)? " immut" : "",
24181da177e4SLinus Torvalds IS_APPEND(inode)? " append" : "",
24192c463e95SDave Hansen __mnt_is_readonly(exp->ex_path.mnt)? " ro" : "");
24201da177e4SLinus Torvalds dprintk(" owner %d/%d user %d/%d\n",
24215cc0a840SDavid Howells inode->i_uid, inode->i_gid, current_fsuid(), current_fsgid());
24221da177e4SLinus Torvalds #endif
24231da177e4SLinus Torvalds
24241da177e4SLinus Torvalds /* Normally we reject any write/sattr etc access on a read-only file
24251da177e4SLinus Torvalds * system. But if it is IRIX doing check on write-access for a
24261da177e4SLinus Torvalds * device special file, we ignore rofs.
24271da177e4SLinus Torvalds */
24288837abcaSMiklos Szeredi if (!(acc & NFSD_MAY_LOCAL_ACCESS))
24298837abcaSMiklos Szeredi if (acc & (NFSD_MAY_WRITE | NFSD_MAY_SATTR | NFSD_MAY_TRUNC)) {
24302c463e95SDave Hansen if (exp_rdonly(rqstp, exp) ||
24312c463e95SDave Hansen __mnt_is_readonly(exp->ex_path.mnt))
24321da177e4SLinus Torvalds return nfserr_rofs;
24338837abcaSMiklos Szeredi if (/* (acc & NFSD_MAY_WRITE) && */ IS_IMMUTABLE(inode))
24341da177e4SLinus Torvalds return nfserr_perm;
24351da177e4SLinus Torvalds }
24368837abcaSMiklos Szeredi if ((acc & NFSD_MAY_TRUNC) && IS_APPEND(inode))
24371da177e4SLinus Torvalds return nfserr_perm;
24381da177e4SLinus Torvalds
24398837abcaSMiklos Szeredi if (acc & NFSD_MAY_LOCK) {
24401da177e4SLinus Torvalds /* If we cannot rely on authentication in NLM requests,
24411da177e4SLinus Torvalds * just allow locks, otherwise require read permission, or
24421da177e4SLinus Torvalds * ownership
24431da177e4SLinus Torvalds */
24441da177e4SLinus Torvalds if (exp->ex_flags & NFSEXP_NOAUTHNLM)
24451da177e4SLinus Torvalds return 0;
24461da177e4SLinus Torvalds else
24478837abcaSMiklos Szeredi acc = NFSD_MAY_READ | NFSD_MAY_OWNER_OVERRIDE;
24481da177e4SLinus Torvalds }
24491da177e4SLinus Torvalds /*
24501da177e4SLinus Torvalds * The file owner always gets access permission for accesses that
24511da177e4SLinus Torvalds * would normally be checked at open time. This is to make
24521da177e4SLinus Torvalds * file access work even when the client has done a fchmod(fd, 0).
24531da177e4SLinus Torvalds *
24541da177e4SLinus Torvalds * However, `cp foo bar' should fail nevertheless when bar is
24551da177e4SLinus Torvalds * readonly. A sensible way to do this might be to reject all
24561da177e4SLinus Torvalds * attempts to truncate a read-only file, because a creat() call
24571da177e4SLinus Torvalds * always implies file truncation.
24581da177e4SLinus Torvalds * ... but this isn't really fair. A process may reasonably call
24591da177e4SLinus Torvalds * ftruncate on an open file descriptor on a file with perm 000.
24601da177e4SLinus Torvalds * We must trust the client to do permission checking - using "ACCESS"
24611da177e4SLinus Torvalds * with NFSv3.
24621da177e4SLinus Torvalds */
24638837abcaSMiklos Szeredi if ((acc & NFSD_MAY_OWNER_OVERRIDE) &&
24646fab8779SEric W. Biederman uid_eq(inode->i_uid, current_fsuid()))
24651da177e4SLinus Torvalds return 0;
24661da177e4SLinus Torvalds
24678837abcaSMiklos Szeredi /* This assumes NFSD_MAY_{READ,WRITE,EXEC} == MAY_{READ,WRITE,EXEC} */
24684609e1f1SChristian Brauner err = inode_permission(&nop_mnt_idmap, inode,
246947291baaSChristian Brauner acc & (MAY_READ | MAY_WRITE | MAY_EXEC));
24701da177e4SLinus Torvalds
24711da177e4SLinus Torvalds /* Allow read access to binaries even when mode 111 */
24721da177e4SLinus Torvalds if (err == -EACCES && S_ISREG(inode->i_mode) &&
2473a043226bSJ. Bruce Fields (acc == (NFSD_MAY_READ | NFSD_MAY_OWNER_OVERRIDE) ||
2474a043226bSJ. Bruce Fields acc == (NFSD_MAY_READ | NFSD_MAY_READ_IF_EXEC)))
24754609e1f1SChristian Brauner err = inode_permission(&nop_mnt_idmap, inode, MAY_EXEC);
24761da177e4SLinus Torvalds
24771da177e4SLinus Torvalds return err? nfserrno(err) : 0;
24781da177e4SLinus Torvalds }
2479