11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * File operations used by nfsd. Some of these have been ripped from 31da177e4SLinus Torvalds * other parts of the kernel because they weren't exported, others 41da177e4SLinus Torvalds * are partial duplicates with added or changed functionality. 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * Note that several functions dget() the dentry upon which they want 71da177e4SLinus Torvalds * to act, most notably those that create directory entries. Response 81da177e4SLinus Torvalds * dentry's are dput()'d if necessary in the release callback. 91da177e4SLinus Torvalds * So if you notice code paths that apparently fail to dput() the 101da177e4SLinus Torvalds * dentry, don't worry--they have been taken care of. 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds * Copyright (C) 1995-1999 Olaf Kirch <okir@monad.swb.de> 131da177e4SLinus Torvalds * Zerocpy NFS support (C) 2002 Hirokazu Takahashi <taka@valinux.co.jp> 141da177e4SLinus Torvalds */ 151da177e4SLinus Torvalds 161da177e4SLinus Torvalds #include <linux/fs.h> 171da177e4SLinus Torvalds #include <linux/file.h> 18d6b29d7cSJens Axboe #include <linux/splice.h> 1995d871f0SAnna Schumaker #include <linux/falloc.h> 201da177e4SLinus Torvalds #include <linux/fcntl.h> 211da177e4SLinus Torvalds #include <linux/namei.h> 221da177e4SLinus Torvalds #include <linux/delay.h> 230eeca283SRobert Love #include <linux/fsnotify.h> 241da177e4SLinus Torvalds #include <linux/posix_acl_xattr.h> 251da177e4SLinus Torvalds #include <linux/xattr.h> 269a74af21SBoaz Harrosh #include <linux/jhash.h> 279a74af21SBoaz Harrosh #include <linux/ima.h> 285a0e3ad6STejun Heo #include <linux/slab.h> 299a74af21SBoaz Harrosh #include <asm/uaccess.h> 30f501912aSBen Myers #include <linux/exportfs.h> 31f501912aSBen Myers #include <linux/writeback.h> 3218032ca0SDavid Quigley #include <linux/security.h> 339a74af21SBoaz Harrosh 349a74af21SBoaz Harrosh #ifdef CONFIG_NFSD_V3 359a74af21SBoaz Harrosh #include "xdr3.h" 369a74af21SBoaz Harrosh #endif /* CONFIG_NFSD_V3 */ 379a74af21SBoaz Harrosh 385be196e5SChristoph Hellwig #ifdef CONFIG_NFSD_V4 392ca72e17SJ. Bruce Fields #include "acl.h" 402ca72e17SJ. Bruce Fields #include "idmap.h" 411da177e4SLinus Torvalds #endif /* CONFIG_NFSD_V4 */ 421da177e4SLinus Torvalds 439a74af21SBoaz Harrosh #include "nfsd.h" 449a74af21SBoaz Harrosh #include "vfs.h" 451da177e4SLinus Torvalds 461da177e4SLinus Torvalds #define NFSDDBG_FACILITY NFSDDBG_FILEOP 471da177e4SLinus Torvalds 481da177e4SLinus Torvalds 491da177e4SLinus Torvalds /* 501da177e4SLinus Torvalds * This is a cache of readahead params that help us choose the proper 511da177e4SLinus Torvalds * readahead strategy. Initially, we set all readahead parameters to 0 521da177e4SLinus Torvalds * and let the VFS handle things. 531da177e4SLinus Torvalds * If you increase the number of cached files very much, you'll need to 541da177e4SLinus Torvalds * add a hash table here. 551da177e4SLinus Torvalds */ 561da177e4SLinus Torvalds struct raparms { 571da177e4SLinus Torvalds struct raparms *p_next; 581da177e4SLinus Torvalds unsigned int p_count; 591da177e4SLinus Torvalds ino_t p_ino; 601da177e4SLinus Torvalds dev_t p_dev; 611da177e4SLinus Torvalds int p_set; 621da177e4SLinus Torvalds struct file_ra_state p_ra; 63fce1456aSGreg Banks unsigned int p_hindex; 641da177e4SLinus Torvalds }; 651da177e4SLinus Torvalds 66fce1456aSGreg Banks struct raparm_hbucket { 67fce1456aSGreg Banks struct raparms *pb_head; 68fce1456aSGreg Banks spinlock_t pb_lock; 69fce1456aSGreg Banks } ____cacheline_aligned_in_smp; 70fce1456aSGreg Banks 71fce1456aSGreg Banks #define RAPARM_HASH_BITS 4 72fce1456aSGreg Banks #define RAPARM_HASH_SIZE (1<<RAPARM_HASH_BITS) 73fce1456aSGreg Banks #define RAPARM_HASH_MASK (RAPARM_HASH_SIZE-1) 74fce1456aSGreg Banks static struct raparm_hbucket raparm_hash[RAPARM_HASH_SIZE]; 751da177e4SLinus Torvalds 761da177e4SLinus Torvalds /* 771da177e4SLinus Torvalds * Called from nfsd_lookup and encode_dirent. Check if we have crossed 781da177e4SLinus Torvalds * a mount point. 79e0bb89efSJ.Bruce Fields * Returns -EAGAIN or -ETIMEDOUT leaving *dpp and *expp unchanged, 801da177e4SLinus Torvalds * or nfs_ok having possibly changed *dpp and *expp 811da177e4SLinus Torvalds */ 821da177e4SLinus Torvalds int 831da177e4SLinus Torvalds nfsd_cross_mnt(struct svc_rqst *rqstp, struct dentry **dpp, 841da177e4SLinus Torvalds struct svc_export **expp) 851da177e4SLinus Torvalds { 861da177e4SLinus Torvalds struct svc_export *exp = *expp, *exp2 = NULL; 871da177e4SLinus Torvalds struct dentry *dentry = *dpp; 8891c9fa8fSAl Viro struct path path = {.mnt = mntget(exp->ex_path.mnt), 8991c9fa8fSAl Viro .dentry = dget(dentry)}; 906264d69dSAl Viro int err = 0; 911da177e4SLinus Torvalds 927cc90cc3SAl Viro err = follow_down(&path); 93cc53ce53SDavid Howells if (err < 0) 94cc53ce53SDavid Howells goto out; 951da177e4SLinus Torvalds 9691c9fa8fSAl Viro exp2 = rqst_exp_get_by_name(rqstp, &path); 971da177e4SLinus Torvalds if (IS_ERR(exp2)) { 981da177e4SLinus Torvalds err = PTR_ERR(exp2); 993b6cee7bSJ. Bruce Fields /* 1003b6cee7bSJ. Bruce Fields * We normally allow NFS clients to continue 1013b6cee7bSJ. Bruce Fields * "underneath" a mountpoint that is not exported. 1023b6cee7bSJ. Bruce Fields * The exception is V4ROOT, where no traversal is ever 1033b6cee7bSJ. Bruce Fields * allowed without an explicit export of the new 1043b6cee7bSJ. Bruce Fields * directory. 1053b6cee7bSJ. Bruce Fields */ 1063b6cee7bSJ. Bruce Fields if (err == -ENOENT && !(exp->ex_flags & NFSEXP_V4ROOT)) 1073b6cee7bSJ. Bruce Fields err = 0; 10891c9fa8fSAl Viro path_put(&path); 1091da177e4SLinus Torvalds goto out; 1101da177e4SLinus Torvalds } 1113c394ddaSSteve Dickson if (nfsd_v4client(rqstp) || 1123c394ddaSSteve Dickson (exp->ex_flags & NFSEXP_CROSSMOUNT) || EX_NOHIDE(exp2)) { 1131da177e4SLinus Torvalds /* successfully crossed mount point */ 1141644ccc8SAl Viro /* 11591c9fa8fSAl Viro * This is subtle: path.dentry is *not* on path.mnt 11691c9fa8fSAl Viro * at this point. The only reason we are safe is that 11791c9fa8fSAl Viro * original mnt is pinned down by exp, so we should 11891c9fa8fSAl Viro * put path *before* putting exp 1191644ccc8SAl Viro */ 12091c9fa8fSAl Viro *dpp = path.dentry; 12191c9fa8fSAl Viro path.dentry = dentry; 1221644ccc8SAl Viro *expp = exp2; 12391c9fa8fSAl Viro exp2 = exp; 1241da177e4SLinus Torvalds } 12591c9fa8fSAl Viro path_put(&path); 12691c9fa8fSAl Viro exp_put(exp2); 1271da177e4SLinus Torvalds out: 1281da177e4SLinus Torvalds return err; 1291da177e4SLinus Torvalds } 1301da177e4SLinus Torvalds 131289ede45SJ. Bruce Fields static void follow_to_parent(struct path *path) 132289ede45SJ. Bruce Fields { 133289ede45SJ. Bruce Fields struct dentry *dp; 134289ede45SJ. Bruce Fields 135289ede45SJ. Bruce Fields while (path->dentry == path->mnt->mnt_root && follow_up(path)) 136289ede45SJ. Bruce Fields ; 137289ede45SJ. Bruce Fields dp = dget_parent(path->dentry); 138289ede45SJ. Bruce Fields dput(path->dentry); 139289ede45SJ. Bruce Fields path->dentry = dp; 140289ede45SJ. Bruce Fields } 141289ede45SJ. Bruce Fields 142289ede45SJ. Bruce Fields static int nfsd_lookup_parent(struct svc_rqst *rqstp, struct dentry *dparent, struct svc_export **exp, struct dentry **dentryp) 143289ede45SJ. Bruce Fields { 144289ede45SJ. Bruce Fields struct svc_export *exp2; 145289ede45SJ. Bruce Fields struct path path = {.mnt = mntget((*exp)->ex_path.mnt), 146289ede45SJ. Bruce Fields .dentry = dget(dparent)}; 147289ede45SJ. Bruce Fields 148289ede45SJ. Bruce Fields follow_to_parent(&path); 149289ede45SJ. Bruce Fields 150289ede45SJ. Bruce Fields exp2 = rqst_exp_parent(rqstp, &path); 151289ede45SJ. Bruce Fields if (PTR_ERR(exp2) == -ENOENT) { 152289ede45SJ. Bruce Fields *dentryp = dget(dparent); 153289ede45SJ. Bruce Fields } else if (IS_ERR(exp2)) { 154289ede45SJ. Bruce Fields path_put(&path); 155289ede45SJ. Bruce Fields return PTR_ERR(exp2); 156289ede45SJ. Bruce Fields } else { 157289ede45SJ. Bruce Fields *dentryp = dget(path.dentry); 158289ede45SJ. Bruce Fields exp_put(*exp); 159289ede45SJ. Bruce Fields *exp = exp2; 160289ede45SJ. Bruce Fields } 161289ede45SJ. Bruce Fields path_put(&path); 162289ede45SJ. Bruce Fields return 0; 163289ede45SJ. Bruce Fields } 164289ede45SJ. Bruce Fields 16582ead7feSJ. Bruce Fields /* 16682ead7feSJ. Bruce Fields * For nfsd purposes, we treat V4ROOT exports as though there was an 16782ead7feSJ. Bruce Fields * export at *every* directory. 16882ead7feSJ. Bruce Fields */ 1693227fa41SJ. Bruce Fields int nfsd_mountpoint(struct dentry *dentry, struct svc_export *exp) 17082ead7feSJ. Bruce Fields { 17182ead7feSJ. Bruce Fields if (d_mountpoint(dentry)) 17282ead7feSJ. Bruce Fields return 1; 17311fcee02STrond Myklebust if (nfsd4_is_junction(dentry)) 17411fcee02STrond Myklebust return 1; 17582ead7feSJ. Bruce Fields if (!(exp->ex_flags & NFSEXP_V4ROOT)) 17682ead7feSJ. Bruce Fields return 0; 177*2b0143b5SDavid Howells return d_inode(dentry) != NULL; 17882ead7feSJ. Bruce Fields } 17982ead7feSJ. Bruce Fields 1806264d69dSAl Viro __be32 1816c0a654dSJ. Bruce Fields nfsd_lookup_dentry(struct svc_rqst *rqstp, struct svc_fh *fhp, 1825a022fc8SChuck Lever const char *name, unsigned int len, 1836c0a654dSJ. Bruce Fields struct svc_export **exp_ret, struct dentry **dentry_ret) 1841da177e4SLinus Torvalds { 1851da177e4SLinus Torvalds struct svc_export *exp; 1861da177e4SLinus Torvalds struct dentry *dparent; 1871da177e4SLinus Torvalds struct dentry *dentry; 1886264d69dSAl Viro int host_err; 1891da177e4SLinus Torvalds 1901da177e4SLinus Torvalds dprintk("nfsd: nfsd_lookup(fh %s, %.*s)\n", SVCFH_fmt(fhp), len,name); 1911da177e4SLinus Torvalds 1921da177e4SLinus Torvalds dparent = fhp->fh_dentry; 193bf18f163SKinglong Mee exp = exp_get(fhp->fh_export); 1941da177e4SLinus Torvalds 1951da177e4SLinus Torvalds /* Lookup the name, but don't follow links */ 1961da177e4SLinus Torvalds if (isdotent(name, len)) { 1971da177e4SLinus Torvalds if (len==1) 1981da177e4SLinus Torvalds dentry = dget(dparent); 19954775491SJan Blunck else if (dparent != exp->ex_path.dentry) 2001da177e4SLinus Torvalds dentry = dget_parent(dparent); 201fed83811SJ. Bruce Fields else if (!EX_NOHIDE(exp) && !nfsd_v4client(rqstp)) 2021da177e4SLinus Torvalds dentry = dget(dparent); /* .. == . just like at / */ 2031da177e4SLinus Torvalds else { 2041da177e4SLinus Torvalds /* checking mountpoint crossing is very different when stepping up */ 205289ede45SJ. Bruce Fields host_err = nfsd_lookup_parent(rqstp, dparent, &exp, &dentry); 206289ede45SJ. Bruce Fields if (host_err) 2071da177e4SLinus Torvalds goto out_nfserr; 2081da177e4SLinus Torvalds } 2091da177e4SLinus Torvalds } else { 2104335723eSJ. Bruce Fields /* 2114335723eSJ. Bruce Fields * In the nfsd4_open() case, this may be held across 2124335723eSJ. Bruce Fields * subsequent open and delegation acquisition which may 2134335723eSJ. Bruce Fields * need to take the child's i_mutex: 2144335723eSJ. Bruce Fields */ 2154335723eSJ. Bruce Fields fh_lock_nested(fhp, I_MUTEX_PARENT); 2161da177e4SLinus Torvalds dentry = lookup_one_len(name, dparent, len); 2176264d69dSAl Viro host_err = PTR_ERR(dentry); 2181da177e4SLinus Torvalds if (IS_ERR(dentry)) 2191da177e4SLinus Torvalds goto out_nfserr; 2201da177e4SLinus Torvalds /* 2211da177e4SLinus Torvalds * check if we have crossed a mount point ... 2221da177e4SLinus Torvalds */ 22382ead7feSJ. Bruce Fields if (nfsd_mountpoint(dentry, exp)) { 2246264d69dSAl Viro if ((host_err = nfsd_cross_mnt(rqstp, &dentry, &exp))) { 2251da177e4SLinus Torvalds dput(dentry); 2261da177e4SLinus Torvalds goto out_nfserr; 2271da177e4SLinus Torvalds } 2281da177e4SLinus Torvalds } 2291da177e4SLinus Torvalds } 2306c0a654dSJ. Bruce Fields *dentry_ret = dentry; 2316c0a654dSJ. Bruce Fields *exp_ret = exp; 2326c0a654dSJ. Bruce Fields return 0; 2336c0a654dSJ. Bruce Fields 2346c0a654dSJ. Bruce Fields out_nfserr: 2356c0a654dSJ. Bruce Fields exp_put(exp); 2366c0a654dSJ. Bruce Fields return nfserrno(host_err); 2376c0a654dSJ. Bruce Fields } 2386c0a654dSJ. Bruce Fields 2396c0a654dSJ. Bruce Fields /* 2406c0a654dSJ. Bruce Fields * Look up one component of a pathname. 2416c0a654dSJ. Bruce Fields * N.B. After this call _both_ fhp and resfh need an fh_put 2426c0a654dSJ. Bruce Fields * 2436c0a654dSJ. Bruce Fields * If the lookup would cross a mountpoint, and the mounted filesystem 2446c0a654dSJ. Bruce Fields * is exported to the client with NFSEXP_NOHIDE, then the lookup is 2456c0a654dSJ. Bruce Fields * accepted as it stands and the mounted directory is 2466c0a654dSJ. Bruce Fields * returned. Otherwise the covered directory is returned. 2476c0a654dSJ. Bruce Fields * NOTE: this mountpoint crossing is not supported properly by all 2486c0a654dSJ. Bruce Fields * clients and is explicitly disallowed for NFSv3 2496c0a654dSJ. Bruce Fields * NeilBrown <neilb@cse.unsw.edu.au> 2506c0a654dSJ. Bruce Fields */ 2516c0a654dSJ. Bruce Fields __be32 2526c0a654dSJ. Bruce Fields nfsd_lookup(struct svc_rqst *rqstp, struct svc_fh *fhp, const char *name, 2535a022fc8SChuck Lever unsigned int len, struct svc_fh *resfh) 2546c0a654dSJ. Bruce Fields { 2556c0a654dSJ. Bruce Fields struct svc_export *exp; 2566c0a654dSJ. Bruce Fields struct dentry *dentry; 2576c0a654dSJ. Bruce Fields __be32 err; 2586c0a654dSJ. Bruce Fields 25929a78a3eSJ. Bruce Fields err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_EXEC); 26029a78a3eSJ. Bruce Fields if (err) 26129a78a3eSJ. Bruce Fields return err; 2626c0a654dSJ. Bruce Fields err = nfsd_lookup_dentry(rqstp, fhp, name, len, &exp, &dentry); 2636c0a654dSJ. Bruce Fields if (err) 2646c0a654dSJ. Bruce Fields return err; 26532c1eb0cSAndy Adamson err = check_nfsd_access(exp, rqstp); 26632c1eb0cSAndy Adamson if (err) 26732c1eb0cSAndy Adamson goto out; 2681da177e4SLinus Torvalds /* 2691da177e4SLinus Torvalds * Note: we compose the file handle now, but as the 2701da177e4SLinus Torvalds * dentry may be negative, it may need to be updated. 2711da177e4SLinus Torvalds */ 2721da177e4SLinus Torvalds err = fh_compose(resfh, exp, dentry, fhp); 273*2b0143b5SDavid Howells if (!err && d_really_is_negative(dentry)) 2741da177e4SLinus Torvalds err = nfserr_noent; 27532c1eb0cSAndy Adamson out: 2761da177e4SLinus Torvalds dput(dentry); 2771da177e4SLinus Torvalds exp_put(exp); 2781da177e4SLinus Torvalds return err; 2791da177e4SLinus Torvalds } 2801da177e4SLinus Torvalds 281f501912aSBen Myers /* 282f501912aSBen Myers * Commit metadata changes to stable storage. 283f501912aSBen Myers */ 284f501912aSBen Myers static int 285f501912aSBen Myers commit_metadata(struct svc_fh *fhp) 286f501912aSBen Myers { 287*2b0143b5SDavid Howells struct inode *inode = d_inode(fhp->fh_dentry); 288f501912aSBen Myers const struct export_operations *export_ops = inode->i_sb->s_export_op; 289f501912aSBen Myers 290f501912aSBen Myers if (!EX_ISSYNC(fhp->fh_export)) 291f501912aSBen Myers return 0; 292f501912aSBen Myers 293c3765016SChristoph Hellwig if (export_ops->commit_metadata) 294c3765016SChristoph Hellwig return export_ops->commit_metadata(inode); 295c3765016SChristoph Hellwig return sync_inode_metadata(inode, 1); 296f501912aSBen Myers } 2976c0a654dSJ. Bruce Fields 2981da177e4SLinus Torvalds /* 299818e5a22SChristoph Hellwig * Go over the attributes and take care of the small differences between 300818e5a22SChristoph Hellwig * NFS semantics and what Linux expects. 301818e5a22SChristoph Hellwig */ 302818e5a22SChristoph Hellwig static void 303818e5a22SChristoph Hellwig nfsd_sanitize_attrs(struct inode *inode, struct iattr *iap) 304818e5a22SChristoph Hellwig { 305818e5a22SChristoph Hellwig /* 306818e5a22SChristoph Hellwig * NFSv2 does not differentiate between "set-[ac]time-to-now" 307818e5a22SChristoph Hellwig * which only requires access, and "set-[ac]time-to-X" which 308818e5a22SChristoph Hellwig * requires ownership. 309818e5a22SChristoph Hellwig * So if it looks like it might be "set both to the same time which 310818e5a22SChristoph Hellwig * is close to now", and if inode_change_ok fails, then we 311818e5a22SChristoph Hellwig * convert to "set to now" instead of "set to explicit time" 312818e5a22SChristoph Hellwig * 313818e5a22SChristoph Hellwig * We only call inode_change_ok as the last test as technically 314818e5a22SChristoph Hellwig * it is not an interface that we should be using. 315818e5a22SChristoph Hellwig */ 316818e5a22SChristoph Hellwig #define BOTH_TIME_SET (ATTR_ATIME_SET | ATTR_MTIME_SET) 317818e5a22SChristoph Hellwig #define MAX_TOUCH_TIME_ERROR (30*60) 318818e5a22SChristoph Hellwig if ((iap->ia_valid & BOTH_TIME_SET) == BOTH_TIME_SET && 319818e5a22SChristoph Hellwig iap->ia_mtime.tv_sec == iap->ia_atime.tv_sec) { 320818e5a22SChristoph Hellwig /* 321818e5a22SChristoph Hellwig * Looks probable. 322818e5a22SChristoph Hellwig * 323818e5a22SChristoph Hellwig * Now just make sure time is in the right ballpark. 324818e5a22SChristoph Hellwig * Solaris, at least, doesn't seem to care what the time 325818e5a22SChristoph Hellwig * request is. We require it be within 30 minutes of now. 326818e5a22SChristoph Hellwig */ 327818e5a22SChristoph Hellwig time_t delta = iap->ia_atime.tv_sec - get_seconds(); 328818e5a22SChristoph Hellwig if (delta < 0) 329818e5a22SChristoph Hellwig delta = -delta; 330818e5a22SChristoph Hellwig if (delta < MAX_TOUCH_TIME_ERROR && 331818e5a22SChristoph Hellwig inode_change_ok(inode, iap) != 0) { 332818e5a22SChristoph Hellwig /* 333818e5a22SChristoph Hellwig * Turn off ATTR_[AM]TIME_SET but leave ATTR_[AM]TIME. 334818e5a22SChristoph Hellwig * This will cause notify_change to set these times 335818e5a22SChristoph Hellwig * to "now" 336818e5a22SChristoph Hellwig */ 337818e5a22SChristoph Hellwig iap->ia_valid &= ~BOTH_TIME_SET; 338818e5a22SChristoph Hellwig } 339818e5a22SChristoph Hellwig } 340818e5a22SChristoph Hellwig 341818e5a22SChristoph Hellwig /* sanitize the mode change */ 342818e5a22SChristoph Hellwig if (iap->ia_valid & ATTR_MODE) { 343818e5a22SChristoph Hellwig iap->ia_mode &= S_IALLUGO; 344818e5a22SChristoph Hellwig iap->ia_mode |= (inode->i_mode & ~S_IALLUGO); 345818e5a22SChristoph Hellwig } 346818e5a22SChristoph Hellwig 347818e5a22SChristoph Hellwig /* Revoke setuid/setgid on chown */ 348818e5a22SChristoph Hellwig if (!S_ISDIR(inode->i_mode) && 349c4fa6d7cSStanislav Kholmanskikh ((iap->ia_valid & ATTR_UID) || (iap->ia_valid & ATTR_GID))) { 350818e5a22SChristoph Hellwig iap->ia_valid |= ATTR_KILL_PRIV; 351818e5a22SChristoph Hellwig if (iap->ia_valid & ATTR_MODE) { 352818e5a22SChristoph Hellwig /* we're setting mode too, just clear the s*id bits */ 353818e5a22SChristoph Hellwig iap->ia_mode &= ~S_ISUID; 354818e5a22SChristoph Hellwig if (iap->ia_mode & S_IXGRP) 355818e5a22SChristoph Hellwig iap->ia_mode &= ~S_ISGID; 356818e5a22SChristoph Hellwig } else { 357818e5a22SChristoph Hellwig /* set ATTR_KILL_* bits and let VFS handle it */ 358818e5a22SChristoph Hellwig iap->ia_valid |= (ATTR_KILL_SUID | ATTR_KILL_SGID); 359818e5a22SChristoph Hellwig } 360818e5a22SChristoph Hellwig } 361818e5a22SChristoph Hellwig } 362818e5a22SChristoph Hellwig 363818e5a22SChristoph Hellwig static __be32 364818e5a22SChristoph Hellwig nfsd_get_write_access(struct svc_rqst *rqstp, struct svc_fh *fhp, 365818e5a22SChristoph Hellwig struct iattr *iap) 366818e5a22SChristoph Hellwig { 367*2b0143b5SDavid Howells struct inode *inode = d_inode(fhp->fh_dentry); 368818e5a22SChristoph Hellwig int host_err; 369818e5a22SChristoph Hellwig 370818e5a22SChristoph Hellwig if (iap->ia_size < inode->i_size) { 371818e5a22SChristoph Hellwig __be32 err; 372818e5a22SChristoph Hellwig 373818e5a22SChristoph Hellwig err = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry, 374818e5a22SChristoph Hellwig NFSD_MAY_TRUNC | NFSD_MAY_OWNER_OVERRIDE); 375818e5a22SChristoph Hellwig if (err) 376818e5a22SChristoph Hellwig return err; 377818e5a22SChristoph Hellwig } 378818e5a22SChristoph Hellwig 379818e5a22SChristoph Hellwig host_err = get_write_access(inode); 380818e5a22SChristoph Hellwig if (host_err) 381818e5a22SChristoph Hellwig goto out_nfserrno; 382818e5a22SChristoph Hellwig 383818e5a22SChristoph Hellwig host_err = locks_verify_truncate(inode, NULL, iap->ia_size); 384818e5a22SChristoph Hellwig if (host_err) 385818e5a22SChristoph Hellwig goto out_put_write_access; 386818e5a22SChristoph Hellwig return 0; 387818e5a22SChristoph Hellwig 388818e5a22SChristoph Hellwig out_put_write_access: 389818e5a22SChristoph Hellwig put_write_access(inode); 390818e5a22SChristoph Hellwig out_nfserrno: 391818e5a22SChristoph Hellwig return nfserrno(host_err); 392818e5a22SChristoph Hellwig } 393818e5a22SChristoph Hellwig 394818e5a22SChristoph Hellwig /* 395818e5a22SChristoph Hellwig * Set various file attributes. After this call fhp needs an fh_put. 3961da177e4SLinus Torvalds */ 3976264d69dSAl Viro __be32 3981da177e4SLinus Torvalds nfsd_setattr(struct svc_rqst *rqstp, struct svc_fh *fhp, struct iattr *iap, 3991da177e4SLinus Torvalds int check_guard, time_t guardtime) 4001da177e4SLinus Torvalds { 4011da177e4SLinus Torvalds struct dentry *dentry; 4021da177e4SLinus Torvalds struct inode *inode; 4038837abcaSMiklos Szeredi int accmode = NFSD_MAY_SATTR; 404175a4eb7SAl Viro umode_t ftype = 0; 4056264d69dSAl Viro __be32 err; 4066264d69dSAl Viro int host_err; 4079f67f189SJ. Bruce Fields bool get_write_count; 4081da177e4SLinus Torvalds int size_change = 0; 4091da177e4SLinus Torvalds 4101da177e4SLinus Torvalds if (iap->ia_valid & (ATTR_ATIME | ATTR_MTIME | ATTR_SIZE)) 4118837abcaSMiklos Szeredi accmode |= NFSD_MAY_WRITE|NFSD_MAY_OWNER_OVERRIDE; 4121da177e4SLinus Torvalds if (iap->ia_valid & ATTR_SIZE) 4131da177e4SLinus Torvalds ftype = S_IFREG; 4141da177e4SLinus Torvalds 4159f67f189SJ. Bruce Fields /* Callers that do fh_verify should do the fh_want_write: */ 4169f67f189SJ. Bruce Fields get_write_count = !fhp->fh_dentry; 4179f67f189SJ. Bruce Fields 4181da177e4SLinus Torvalds /* Get inode */ 4191da177e4SLinus Torvalds err = fh_verify(rqstp, fhp, ftype, accmode); 42015b7a1b8SNeilBrown if (err) 4211da177e4SLinus Torvalds goto out; 4229f67f189SJ. Bruce Fields if (get_write_count) { 4239f67f189SJ. Bruce Fields host_err = fh_want_write(fhp); 4249f67f189SJ. Bruce Fields if (host_err) 4259f67f189SJ. Bruce Fields return nfserrno(host_err); 4269f67f189SJ. Bruce Fields } 4271da177e4SLinus Torvalds 4281da177e4SLinus Torvalds dentry = fhp->fh_dentry; 429*2b0143b5SDavid Howells inode = d_inode(dentry); 4301da177e4SLinus Torvalds 43115b7a1b8SNeilBrown /* Ignore any mode updates on symlinks */ 43215b7a1b8SNeilBrown if (S_ISLNK(inode->i_mode)) 43315b7a1b8SNeilBrown iap->ia_valid &= ~ATTR_MODE; 43415b7a1b8SNeilBrown 43515b7a1b8SNeilBrown if (!iap->ia_valid) 43615b7a1b8SNeilBrown goto out; 43715b7a1b8SNeilBrown 438818e5a22SChristoph Hellwig nfsd_sanitize_attrs(inode, iap); 4391da177e4SLinus Torvalds 4409c85fca5SChristoph Hellwig /* 441818e5a22SChristoph Hellwig * The size case is special, it changes the file in addition to the 442818e5a22SChristoph Hellwig * attributes. 4439c85fca5SChristoph Hellwig */ 4441da177e4SLinus Torvalds if (iap->ia_valid & ATTR_SIZE) { 445818e5a22SChristoph Hellwig err = nfsd_get_write_access(rqstp, fhp, iap); 4461da177e4SLinus Torvalds if (err) 4471da177e4SLinus Torvalds goto out; 4481da177e4SLinus Torvalds size_change = 1; 449f0c63124SChristoph Hellwig 450f0c63124SChristoph Hellwig /* 451f0c63124SChristoph Hellwig * RFC5661, Section 18.30.4: 452f0c63124SChristoph Hellwig * Changing the size of a file with SETATTR indirectly 453f0c63124SChristoph Hellwig * changes the time_modify and change attributes. 454f0c63124SChristoph Hellwig * 455f0c63124SChristoph Hellwig * (and similar for the older RFCs) 456f0c63124SChristoph Hellwig */ 457f0c63124SChristoph Hellwig if (iap->ia_size != i_size_read(inode)) 458f0c63124SChristoph Hellwig iap->ia_valid |= ATTR_MTIME; 4591da177e4SLinus Torvalds } 4601da177e4SLinus Torvalds 4611da177e4SLinus Torvalds iap->ia_valid |= ATTR_CTIME; 4621da177e4SLinus Torvalds 463987da479SChristoph Hellwig if (check_guard && guardtime != inode->i_ctime.tv_sec) { 4641da177e4SLinus Torvalds err = nfserr_notsync; 465987da479SChristoph Hellwig goto out_put_write_access; 466987da479SChristoph Hellwig } 467987da479SChristoph Hellwig 468987da479SChristoph Hellwig fh_lock(fhp); 46927ac0ffeSJ. Bruce Fields host_err = notify_change(dentry, iap, NULL); 4701da177e4SLinus Torvalds fh_unlock(fhp); 4711406b916SJ. R. Okajima err = nfserrno(host_err); 472987da479SChristoph Hellwig 473987da479SChristoph Hellwig out_put_write_access: 4741da177e4SLinus Torvalds if (size_change) 4751da177e4SLinus Torvalds put_write_access(inode); 4761da177e4SLinus Torvalds if (!err) 477722b620dSJeff Layton err = nfserrno(commit_metadata(fhp)); 4781da177e4SLinus Torvalds out: 4791da177e4SLinus Torvalds return err; 4801da177e4SLinus Torvalds } 4811da177e4SLinus Torvalds 4825be196e5SChristoph Hellwig #if defined(CONFIG_NFSD_V4) 4839b4146e8SChuck Lever /* 4849b4146e8SChuck Lever * NFS junction information is stored in an extended attribute. 4859b4146e8SChuck Lever */ 4869b4146e8SChuck Lever #define NFSD_JUNCTION_XATTR_NAME XATTR_TRUSTED_PREFIX "junction.nfs" 4879b4146e8SChuck Lever 4889b4146e8SChuck Lever /** 4899b4146e8SChuck Lever * nfsd4_is_junction - Test if an object could be an NFS junction 4909b4146e8SChuck Lever * 4919b4146e8SChuck Lever * @dentry: object to test 4929b4146e8SChuck Lever * 4939b4146e8SChuck Lever * Returns 1 if "dentry" appears to contain NFS junction information. 4949b4146e8SChuck Lever * Otherwise 0 is returned. 4959b4146e8SChuck Lever */ 49611fcee02STrond Myklebust int nfsd4_is_junction(struct dentry *dentry) 49711fcee02STrond Myklebust { 498*2b0143b5SDavid Howells struct inode *inode = d_inode(dentry); 49911fcee02STrond Myklebust 50011fcee02STrond Myklebust if (inode == NULL) 50111fcee02STrond Myklebust return 0; 50211fcee02STrond Myklebust if (inode->i_mode & S_IXUGO) 50311fcee02STrond Myklebust return 0; 50411fcee02STrond Myklebust if (!(inode->i_mode & S_ISVTX)) 50511fcee02STrond Myklebust return 0; 5069b4146e8SChuck Lever if (vfs_getxattr(dentry, NFSD_JUNCTION_XATTR_NAME, NULL, 0) <= 0) 50711fcee02STrond Myklebust return 0; 50811fcee02STrond Myklebust return 1; 50911fcee02STrond Myklebust } 51018032ca0SDavid Quigley #ifdef CONFIG_NFSD_V4_SECURITY_LABEL 51118032ca0SDavid Quigley __be32 nfsd4_set_nfs4_label(struct svc_rqst *rqstp, struct svc_fh *fhp, 51218032ca0SDavid Quigley struct xdr_netobj *label) 51318032ca0SDavid Quigley { 51418032ca0SDavid Quigley __be32 error; 51518032ca0SDavid Quigley int host_error; 51618032ca0SDavid Quigley struct dentry *dentry; 51718032ca0SDavid Quigley 51818032ca0SDavid Quigley error = fh_verify(rqstp, fhp, 0 /* S_IFREG */, NFSD_MAY_SATTR); 51918032ca0SDavid Quigley if (error) 52018032ca0SDavid Quigley return error; 52118032ca0SDavid Quigley 52218032ca0SDavid Quigley dentry = fhp->fh_dentry; 52318032ca0SDavid Quigley 524*2b0143b5SDavid Howells mutex_lock(&d_inode(dentry)->i_mutex); 52518032ca0SDavid Quigley host_error = security_inode_setsecctx(dentry, label->data, label->len); 526*2b0143b5SDavid Howells mutex_unlock(&d_inode(dentry)->i_mutex); 52718032ca0SDavid Quigley return nfserrno(host_error); 52818032ca0SDavid Quigley } 52918032ca0SDavid Quigley #else 53018032ca0SDavid Quigley __be32 nfsd4_set_nfs4_label(struct svc_rqst *rqstp, struct svc_fh *fhp, 53118032ca0SDavid Quigley struct xdr_netobj *label) 53218032ca0SDavid Quigley { 53318032ca0SDavid Quigley return nfserr_notsupp; 53418032ca0SDavid Quigley } 53518032ca0SDavid Quigley #endif 53618032ca0SDavid Quigley 53795d871f0SAnna Schumaker __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp, 53895d871f0SAnna Schumaker struct file *file, loff_t offset, loff_t len, 53995d871f0SAnna Schumaker int flags) 54095d871f0SAnna Schumaker { 54195d871f0SAnna Schumaker __be32 err; 54295d871f0SAnna Schumaker int error; 54395d871f0SAnna Schumaker 54495d871f0SAnna Schumaker if (!S_ISREG(file_inode(file)->i_mode)) 54595d871f0SAnna Schumaker return nfserr_inval; 54695d871f0SAnna Schumaker 54795d871f0SAnna Schumaker err = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry, NFSD_MAY_WRITE); 54895d871f0SAnna Schumaker if (err) 54995d871f0SAnna Schumaker return err; 55095d871f0SAnna Schumaker 55195d871f0SAnna Schumaker error = vfs_fallocate(file, flags, offset, len); 55295d871f0SAnna Schumaker if (!error) 55395d871f0SAnna Schumaker error = commit_metadata(fhp); 55495d871f0SAnna Schumaker 55595d871f0SAnna Schumaker return nfserrno(error); 55695d871f0SAnna Schumaker } 5576a85d6c7SJ. Bruce Fields #endif /* defined(CONFIG_NFSD_V4) */ 5581da177e4SLinus Torvalds 5591da177e4SLinus Torvalds #ifdef CONFIG_NFSD_V3 5601da177e4SLinus Torvalds /* 5611da177e4SLinus Torvalds * Check server access rights to a file system object 5621da177e4SLinus Torvalds */ 5631da177e4SLinus Torvalds struct accessmap { 5641da177e4SLinus Torvalds u32 access; 5651da177e4SLinus Torvalds int how; 5661da177e4SLinus Torvalds }; 5671da177e4SLinus Torvalds static struct accessmap nfs3_regaccess[] = { 5688837abcaSMiklos Szeredi { NFS3_ACCESS_READ, NFSD_MAY_READ }, 5698837abcaSMiklos Szeredi { NFS3_ACCESS_EXECUTE, NFSD_MAY_EXEC }, 5708837abcaSMiklos Szeredi { NFS3_ACCESS_MODIFY, NFSD_MAY_WRITE|NFSD_MAY_TRUNC }, 5718837abcaSMiklos Szeredi { NFS3_ACCESS_EXTEND, NFSD_MAY_WRITE }, 5721da177e4SLinus Torvalds 5731da177e4SLinus Torvalds { 0, 0 } 5741da177e4SLinus Torvalds }; 5751da177e4SLinus Torvalds 5761da177e4SLinus Torvalds static struct accessmap nfs3_diraccess[] = { 5778837abcaSMiklos Szeredi { NFS3_ACCESS_READ, NFSD_MAY_READ }, 5788837abcaSMiklos Szeredi { NFS3_ACCESS_LOOKUP, NFSD_MAY_EXEC }, 5798837abcaSMiklos Szeredi { NFS3_ACCESS_MODIFY, NFSD_MAY_EXEC|NFSD_MAY_WRITE|NFSD_MAY_TRUNC}, 5808837abcaSMiklos Szeredi { NFS3_ACCESS_EXTEND, NFSD_MAY_EXEC|NFSD_MAY_WRITE }, 5818837abcaSMiklos Szeredi { NFS3_ACCESS_DELETE, NFSD_MAY_REMOVE }, 5821da177e4SLinus Torvalds 5831da177e4SLinus Torvalds { 0, 0 } 5841da177e4SLinus Torvalds }; 5851da177e4SLinus Torvalds 5861da177e4SLinus Torvalds static struct accessmap nfs3_anyaccess[] = { 5871da177e4SLinus Torvalds /* Some clients - Solaris 2.6 at least, make an access call 5881da177e4SLinus Torvalds * to the server to check for access for things like /dev/null 5891da177e4SLinus Torvalds * (which really, the server doesn't care about). So 5901da177e4SLinus Torvalds * We provide simple access checking for them, looking 5911da177e4SLinus Torvalds * mainly at mode bits, and we make sure to ignore read-only 5921da177e4SLinus Torvalds * filesystem checks 5931da177e4SLinus Torvalds */ 5948837abcaSMiklos Szeredi { NFS3_ACCESS_READ, NFSD_MAY_READ }, 5958837abcaSMiklos Szeredi { NFS3_ACCESS_EXECUTE, NFSD_MAY_EXEC }, 5968837abcaSMiklos Szeredi { NFS3_ACCESS_MODIFY, NFSD_MAY_WRITE|NFSD_MAY_LOCAL_ACCESS }, 5978837abcaSMiklos Szeredi { NFS3_ACCESS_EXTEND, NFSD_MAY_WRITE|NFSD_MAY_LOCAL_ACCESS }, 5981da177e4SLinus Torvalds 5991da177e4SLinus Torvalds { 0, 0 } 6001da177e4SLinus Torvalds }; 6011da177e4SLinus Torvalds 6026264d69dSAl Viro __be32 6031da177e4SLinus Torvalds nfsd_access(struct svc_rqst *rqstp, struct svc_fh *fhp, u32 *access, u32 *supported) 6041da177e4SLinus Torvalds { 6051da177e4SLinus Torvalds struct accessmap *map; 6061da177e4SLinus Torvalds struct svc_export *export; 6071da177e4SLinus Torvalds struct dentry *dentry; 6081da177e4SLinus Torvalds u32 query, result = 0, sresult = 0; 6096264d69dSAl Viro __be32 error; 6101da177e4SLinus Torvalds 6118837abcaSMiklos Szeredi error = fh_verify(rqstp, fhp, 0, NFSD_MAY_NOP); 6121da177e4SLinus Torvalds if (error) 6131da177e4SLinus Torvalds goto out; 6141da177e4SLinus Torvalds 6151da177e4SLinus Torvalds export = fhp->fh_export; 6161da177e4SLinus Torvalds dentry = fhp->fh_dentry; 6171da177e4SLinus Torvalds 618e36cb0b8SDavid Howells if (d_is_reg(dentry)) 6191da177e4SLinus Torvalds map = nfs3_regaccess; 620e36cb0b8SDavid Howells else if (d_is_dir(dentry)) 6211da177e4SLinus Torvalds map = nfs3_diraccess; 6221da177e4SLinus Torvalds else 6231da177e4SLinus Torvalds map = nfs3_anyaccess; 6241da177e4SLinus Torvalds 6251da177e4SLinus Torvalds 6261da177e4SLinus Torvalds query = *access; 6271da177e4SLinus Torvalds for (; map->access; map++) { 6281da177e4SLinus Torvalds if (map->access & query) { 6296264d69dSAl Viro __be32 err2; 6301da177e4SLinus Torvalds 6311da177e4SLinus Torvalds sresult |= map->access; 6321da177e4SLinus Torvalds 6330ec757dfSJ. Bruce Fields err2 = nfsd_permission(rqstp, export, dentry, map->how); 6341da177e4SLinus Torvalds switch (err2) { 6351da177e4SLinus Torvalds case nfs_ok: 6361da177e4SLinus Torvalds result |= map->access; 6371da177e4SLinus Torvalds break; 6381da177e4SLinus Torvalds 6391da177e4SLinus Torvalds /* the following error codes just mean the access was not allowed, 6401da177e4SLinus Torvalds * rather than an error occurred */ 6411da177e4SLinus Torvalds case nfserr_rofs: 6421da177e4SLinus Torvalds case nfserr_acces: 6431da177e4SLinus Torvalds case nfserr_perm: 6441da177e4SLinus Torvalds /* simply don't "or" in the access bit. */ 6451da177e4SLinus Torvalds break; 6461da177e4SLinus Torvalds default: 6471da177e4SLinus Torvalds error = err2; 6481da177e4SLinus Torvalds goto out; 6491da177e4SLinus Torvalds } 6501da177e4SLinus Torvalds } 6511da177e4SLinus Torvalds } 6521da177e4SLinus Torvalds *access = result; 6531da177e4SLinus Torvalds if (supported) 6541da177e4SLinus Torvalds *supported = sresult; 6551da177e4SLinus Torvalds 6561da177e4SLinus Torvalds out: 6571da177e4SLinus Torvalds return error; 6581da177e4SLinus Torvalds } 6591da177e4SLinus Torvalds #endif /* CONFIG_NFSD_V3 */ 6601da177e4SLinus Torvalds 661105f4622SJ. Bruce Fields static int nfsd_open_break_lease(struct inode *inode, int access) 662105f4622SJ. Bruce Fields { 663105f4622SJ. Bruce Fields unsigned int mode; 6641da177e4SLinus Torvalds 665105f4622SJ. Bruce Fields if (access & NFSD_MAY_NOT_BREAK_LEASE) 666105f4622SJ. Bruce Fields return 0; 667105f4622SJ. Bruce Fields mode = (access & NFSD_MAY_WRITE) ? O_WRONLY : O_RDONLY; 668105f4622SJ. Bruce Fields return break_lease(inode, mode | O_NONBLOCK); 669105f4622SJ. Bruce Fields } 6701da177e4SLinus Torvalds 6711da177e4SLinus Torvalds /* 6721da177e4SLinus Torvalds * Open an existing file or directory. 673999448a8SBernd Schubert * The may_flags argument indicates the type of open (read/write/lock) 674999448a8SBernd Schubert * and additional flags. 6751da177e4SLinus Torvalds * N.B. After this call fhp needs an fh_put 6761da177e4SLinus Torvalds */ 6776264d69dSAl Viro __be32 678175a4eb7SAl Viro nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, umode_t type, 679999448a8SBernd Schubert int may_flags, struct file **filp) 6801da177e4SLinus Torvalds { 681765927b2SAl Viro struct path path; 6821da177e4SLinus Torvalds struct inode *inode; 6838519f994SKinglong Mee struct file *file; 6846264d69dSAl Viro int flags = O_RDONLY|O_LARGEFILE; 6856264d69dSAl Viro __be32 err; 68691885258SJeff Layton int host_err = 0; 6871da177e4SLinus Torvalds 688e0e81739SDavid Howells validate_process_creds(); 689e0e81739SDavid Howells 6901da177e4SLinus Torvalds /* 6911da177e4SLinus Torvalds * If we get here, then the client has already done an "open", 6921da177e4SLinus Torvalds * and (hopefully) checked permission - so allow OWNER_OVERRIDE 6931da177e4SLinus Torvalds * in case a chmod has now revoked permission. 694d91d0b56SJ. Bruce Fields * 695d91d0b56SJ. Bruce Fields * Arguably we should also allow the owner override for 696d91d0b56SJ. Bruce Fields * directories, but we never have and it doesn't seem to have 697d91d0b56SJ. Bruce Fields * caused anyone a problem. If we were to change this, note 698d91d0b56SJ. Bruce Fields * also that our filldir callbacks would need a variant of 699d91d0b56SJ. Bruce Fields * lookup_one_len that doesn't check permissions. 7001da177e4SLinus Torvalds */ 701d91d0b56SJ. Bruce Fields if (type == S_IFREG) 702d91d0b56SJ. Bruce Fields may_flags |= NFSD_MAY_OWNER_OVERRIDE; 703d91d0b56SJ. Bruce Fields err = fh_verify(rqstp, fhp, type, may_flags); 7041da177e4SLinus Torvalds if (err) 7051da177e4SLinus Torvalds goto out; 7061da177e4SLinus Torvalds 707765927b2SAl Viro path.mnt = fhp->fh_export->ex_path.mnt; 708765927b2SAl Viro path.dentry = fhp->fh_dentry; 709*2b0143b5SDavid Howells inode = d_inode(path.dentry); 7101da177e4SLinus Torvalds 7111da177e4SLinus Torvalds /* Disallow write access to files with the append-only bit set 7121da177e4SLinus Torvalds * or any access when mandatory locking enabled 7131da177e4SLinus Torvalds */ 7141da177e4SLinus Torvalds err = nfserr_perm; 715999448a8SBernd Schubert if (IS_APPEND(inode) && (may_flags & NFSD_MAY_WRITE)) 7161da177e4SLinus Torvalds goto out; 7175e7fc436SJ. Bruce Fields /* 7185e7fc436SJ. Bruce Fields * We must ignore files (but only files) which might have mandatory 7195e7fc436SJ. Bruce Fields * locks on them because there is no way to know if the accesser has 7205e7fc436SJ. Bruce Fields * the lock. 7215e7fc436SJ. Bruce Fields */ 7225e7fc436SJ. Bruce Fields if (S_ISREG((inode)->i_mode) && mandatory_lock(inode)) 7231da177e4SLinus Torvalds goto out; 7241da177e4SLinus Torvalds 7251da177e4SLinus Torvalds if (!inode->i_fop) 7261da177e4SLinus Torvalds goto out; 7271da177e4SLinus Torvalds 728999448a8SBernd Schubert host_err = nfsd_open_break_lease(inode, may_flags); 7296264d69dSAl Viro if (host_err) /* NOMEM or WOULDBLOCK */ 7301da177e4SLinus Torvalds goto out_nfserr; 7311da177e4SLinus Torvalds 732999448a8SBernd Schubert if (may_flags & NFSD_MAY_WRITE) { 733999448a8SBernd Schubert if (may_flags & NFSD_MAY_READ) 7349ecb6a08SJ. Bruce Fields flags = O_RDWR|O_LARGEFILE; 7359ecb6a08SJ. Bruce Fields else 7361da177e4SLinus Torvalds flags = O_WRONLY|O_LARGEFILE; 7371da177e4SLinus Torvalds } 738999448a8SBernd Schubert 7398519f994SKinglong Mee file = dentry_open(&path, flags, current_cred()); 7408519f994SKinglong Mee if (IS_ERR(file)) { 7418519f994SKinglong Mee host_err = PTR_ERR(file); 7428519f994SKinglong Mee goto out_nfserr; 74306effdbbSBernd Schubert } 74406effdbbSBernd Schubert 7455e40d331SLinus Torvalds host_err = ima_file_check(file, may_flags, 0); 7468519f994SKinglong Mee if (host_err) { 7478519f994SKinglong Mee nfsd_close(file); 7488519f994SKinglong Mee goto out_nfserr; 7498519f994SKinglong Mee } 7508519f994SKinglong Mee 7518519f994SKinglong Mee if (may_flags & NFSD_MAY_64BIT_COOKIE) 7528519f994SKinglong Mee file->f_mode |= FMODE_64BITHASH; 7538519f994SKinglong Mee else 7548519f994SKinglong Mee file->f_mode |= FMODE_32BITHASH; 7558519f994SKinglong Mee 7568519f994SKinglong Mee *filp = file; 7571da177e4SLinus Torvalds out_nfserr: 7586264d69dSAl Viro err = nfserrno(host_err); 7591da177e4SLinus Torvalds out: 760e0e81739SDavid Howells validate_process_creds(); 7611da177e4SLinus Torvalds return err; 7621da177e4SLinus Torvalds } 7631da177e4SLinus Torvalds 7641da177e4SLinus Torvalds /* 7651da177e4SLinus Torvalds * Close a file. 7661da177e4SLinus Torvalds */ 7671da177e4SLinus Torvalds void 7681da177e4SLinus Torvalds nfsd_close(struct file *filp) 7691da177e4SLinus Torvalds { 7701da177e4SLinus Torvalds fput(filp); 7711da177e4SLinus Torvalds } 7721da177e4SLinus Torvalds 7739a8d248eSJ. Bruce Fields /* 7741da177e4SLinus Torvalds * Obtain the readahead parameters for the file 7751da177e4SLinus Torvalds * specified by (dev, ino). 7761da177e4SLinus Torvalds */ 7771da177e4SLinus Torvalds 7781da177e4SLinus Torvalds static inline struct raparms * 7791da177e4SLinus Torvalds nfsd_get_raparms(dev_t dev, ino_t ino) 7801da177e4SLinus Torvalds { 7811da177e4SLinus Torvalds struct raparms *ra, **rap, **frap = NULL; 7821da177e4SLinus Torvalds int depth = 0; 783fce1456aSGreg Banks unsigned int hash; 784fce1456aSGreg Banks struct raparm_hbucket *rab; 7851da177e4SLinus Torvalds 786fce1456aSGreg Banks hash = jhash_2words(dev, ino, 0xfeedbeef) & RAPARM_HASH_MASK; 787fce1456aSGreg Banks rab = &raparm_hash[hash]; 788fce1456aSGreg Banks 789fce1456aSGreg Banks spin_lock(&rab->pb_lock); 790fce1456aSGreg Banks for (rap = &rab->pb_head; (ra = *rap); rap = &ra->p_next) { 7911da177e4SLinus Torvalds if (ra->p_ino == ino && ra->p_dev == dev) 7921da177e4SLinus Torvalds goto found; 7931da177e4SLinus Torvalds depth++; 7941da177e4SLinus Torvalds if (ra->p_count == 0) 7951da177e4SLinus Torvalds frap = rap; 7961da177e4SLinus Torvalds } 7973aa6e0aaSKonstantin Khorenko depth = nfsdstats.ra_size; 7981da177e4SLinus Torvalds if (!frap) { 799fce1456aSGreg Banks spin_unlock(&rab->pb_lock); 8001da177e4SLinus Torvalds return NULL; 8011da177e4SLinus Torvalds } 8021da177e4SLinus Torvalds rap = frap; 8031da177e4SLinus Torvalds ra = *frap; 8041da177e4SLinus Torvalds ra->p_dev = dev; 8051da177e4SLinus Torvalds ra->p_ino = ino; 8061da177e4SLinus Torvalds ra->p_set = 0; 807fce1456aSGreg Banks ra->p_hindex = hash; 8081da177e4SLinus Torvalds found: 809fce1456aSGreg Banks if (rap != &rab->pb_head) { 8101da177e4SLinus Torvalds *rap = ra->p_next; 811fce1456aSGreg Banks ra->p_next = rab->pb_head; 812fce1456aSGreg Banks rab->pb_head = ra; 8131da177e4SLinus Torvalds } 8141da177e4SLinus Torvalds ra->p_count++; 8151da177e4SLinus Torvalds nfsdstats.ra_depth[depth*10/nfsdstats.ra_size]++; 816fce1456aSGreg Banks spin_unlock(&rab->pb_lock); 8171da177e4SLinus Torvalds return ra; 8181da177e4SLinus Torvalds } 8191da177e4SLinus Torvalds 8201da177e4SLinus Torvalds /* 821cf8208d0SJens Axboe * Grab and keep cached pages associated with a file in the svc_rqst 822cf8208d0SJens Axboe * so that they can be passed to the network sendmsg/sendpage routines 823cf8208d0SJens Axboe * directly. They will be released after the sending has completed. 8241da177e4SLinus Torvalds */ 8251da177e4SLinus Torvalds static int 826cf8208d0SJens Axboe nfsd_splice_actor(struct pipe_inode_info *pipe, struct pipe_buffer *buf, 827cf8208d0SJens Axboe struct splice_desc *sd) 8281da177e4SLinus Torvalds { 829cf8208d0SJens Axboe struct svc_rqst *rqstp = sd->u.data; 830afc59400SJ. Bruce Fields struct page **pp = rqstp->rq_next_page; 831cf8208d0SJens Axboe struct page *page = buf->page; 832cf8208d0SJens Axboe size_t size; 833cf8208d0SJens Axboe 834cf8208d0SJens Axboe size = sd->len; 8351da177e4SLinus Torvalds 8361da177e4SLinus Torvalds if (rqstp->rq_res.page_len == 0) { 8371da177e4SLinus Torvalds get_page(page); 838afc59400SJ. Bruce Fields put_page(*rqstp->rq_next_page); 839afc59400SJ. Bruce Fields *(rqstp->rq_next_page++) = page; 840cf8208d0SJens Axboe rqstp->rq_res.page_base = buf->offset; 8411da177e4SLinus Torvalds rqstp->rq_res.page_len = size; 84244524359SNeilBrown } else if (page != pp[-1]) { 8431da177e4SLinus Torvalds get_page(page); 844afc59400SJ. Bruce Fields if (*rqstp->rq_next_page) 845afc59400SJ. Bruce Fields put_page(*rqstp->rq_next_page); 846afc59400SJ. Bruce Fields *(rqstp->rq_next_page++) = page; 8471da177e4SLinus Torvalds rqstp->rq_res.page_len += size; 84844524359SNeilBrown } else 8491da177e4SLinus Torvalds rqstp->rq_res.page_len += size; 8501da177e4SLinus Torvalds 8511da177e4SLinus Torvalds return size; 8521da177e4SLinus Torvalds } 8531da177e4SLinus Torvalds 854cf8208d0SJens Axboe static int nfsd_direct_splice_actor(struct pipe_inode_info *pipe, 855cf8208d0SJens Axboe struct splice_desc *sd) 856cf8208d0SJens Axboe { 857cf8208d0SJens Axboe return __splice_from_pipe(pipe, sd, nfsd_splice_actor); 858cf8208d0SJens Axboe } 859cf8208d0SJens Axboe 860e2afc819SJeff Layton static __be32 861e2afc819SJeff Layton nfsd_finish_read(struct file *file, unsigned long *count, int host_err) 8621da177e4SLinus Torvalds { 863dc97618dSJ. Bruce Fields if (host_err >= 0) { 864dc97618dSJ. Bruce Fields nfsdstats.io_read += host_err; 865dc97618dSJ. Bruce Fields *count = host_err; 866dc97618dSJ. Bruce Fields fsnotify_access(file); 867dc97618dSJ. Bruce Fields return 0; 868dc97618dSJ. Bruce Fields } else 869dc97618dSJ. Bruce Fields return nfserrno(host_err); 870dc97618dSJ. Bruce Fields } 8711da177e4SLinus Torvalds 872e2afc819SJeff Layton __be32 nfsd_splice_read(struct svc_rqst *rqstp, 873dc97618dSJ. Bruce Fields struct file *file, loff_t offset, unsigned long *count) 874dc97618dSJ. Bruce Fields { 875cf8208d0SJens Axboe struct splice_desc sd = { 876cf8208d0SJens Axboe .len = 0, 877cf8208d0SJens Axboe .total_len = *count, 878cf8208d0SJens Axboe .pos = offset, 879cf8208d0SJens Axboe .u.data = rqstp, 880cf8208d0SJens Axboe }; 881dc97618dSJ. Bruce Fields int host_err; 882cf8208d0SJens Axboe 883afc59400SJ. Bruce Fields rqstp->rq_next_page = rqstp->rq_respages + 1; 884cf8208d0SJens Axboe host_err = splice_direct_to_actor(file, &sd, nfsd_direct_splice_actor); 885dc97618dSJ. Bruce Fields return nfsd_finish_read(file, count, host_err); 886dc97618dSJ. Bruce Fields } 887dc97618dSJ. Bruce Fields 888e2afc819SJeff Layton __be32 nfsd_readv(struct file *file, loff_t offset, struct kvec *vec, int vlen, 889dc97618dSJ. Bruce Fields unsigned long *count) 890dc97618dSJ. Bruce Fields { 891dc97618dSJ. Bruce Fields mm_segment_t oldfs; 892dc97618dSJ. Bruce Fields int host_err; 893dc97618dSJ. Bruce Fields 8941da177e4SLinus Torvalds oldfs = get_fs(); 8951da177e4SLinus Torvalds set_fs(KERNEL_DS); 8966264d69dSAl Viro host_err = vfs_readv(file, (struct iovec __user *)vec, vlen, &offset); 8971da177e4SLinus Torvalds set_fs(oldfs); 898dc97618dSJ. Bruce Fields return nfsd_finish_read(file, count, host_err); 8991da177e4SLinus Torvalds } 9001da177e4SLinus Torvalds 901dc97618dSJ. Bruce Fields static __be32 902dc97618dSJ. Bruce Fields nfsd_vfs_read(struct svc_rqst *rqstp, struct file *file, 903dc97618dSJ. Bruce Fields loff_t offset, struct kvec *vec, int vlen, unsigned long *count) 904dc97618dSJ. Bruce Fields { 905779fb0f3SJeff Layton if (file->f_op->splice_read && test_bit(RQ_SPLICE_OK, &rqstp->rq_flags)) 906dc97618dSJ. Bruce Fields return nfsd_splice_read(rqstp, file, offset, count); 907dc97618dSJ. Bruce Fields else 908dc97618dSJ. Bruce Fields return nfsd_readv(file, offset, vec, vlen, count); 9091da177e4SLinus Torvalds } 9101da177e4SLinus Torvalds 911d911df7bSJ. Bruce Fields /* 912d911df7bSJ. Bruce Fields * Gathered writes: If another process is currently writing to the file, 913d911df7bSJ. Bruce Fields * there's a high chance this is another nfsd (triggered by a bulk write 914d911df7bSJ. Bruce Fields * from a client's biod). Rather than syncing the file with each write 915d911df7bSJ. Bruce Fields * request, we sleep for 10 msec. 916d911df7bSJ. Bruce Fields * 917d911df7bSJ. Bruce Fields * I don't know if this roughly approximates C. Juszak's idea of 918d911df7bSJ. Bruce Fields * gathered writes, but it's a nice and simple solution (IMHO), and it 919d911df7bSJ. Bruce Fields * seems to work:-) 920d911df7bSJ. Bruce Fields * 921d911df7bSJ. Bruce Fields * Note: we do this only in the NFSv2 case, since v3 and higher have a 922d911df7bSJ. Bruce Fields * better tool (separate unstable writes and commits) for solving this 923d911df7bSJ. Bruce Fields * problem. 924d911df7bSJ. Bruce Fields */ 925d911df7bSJ. Bruce Fields static int wait_for_concurrent_writes(struct file *file) 926d911df7bSJ. Bruce Fields { 927496ad9aaSAl Viro struct inode *inode = file_inode(file); 928d911df7bSJ. Bruce Fields static ino_t last_ino; 929d911df7bSJ. Bruce Fields static dev_t last_dev; 930d911df7bSJ. Bruce Fields int err = 0; 931d911df7bSJ. Bruce Fields 932d911df7bSJ. Bruce Fields if (atomic_read(&inode->i_writecount) > 1 933d911df7bSJ. Bruce Fields || (last_ino == inode->i_ino && last_dev == inode->i_sb->s_dev)) { 934d911df7bSJ. Bruce Fields dprintk("nfsd: write defer %d\n", task_pid_nr(current)); 935d911df7bSJ. Bruce Fields msleep(10); 936d911df7bSJ. Bruce Fields dprintk("nfsd: write resume %d\n", task_pid_nr(current)); 937d911df7bSJ. Bruce Fields } 938d911df7bSJ. Bruce Fields 939d911df7bSJ. Bruce Fields if (inode->i_state & I_DIRTY) { 940d911df7bSJ. Bruce Fields dprintk("nfsd: write sync %d\n", task_pid_nr(current)); 9418018ab05SChristoph Hellwig err = vfs_fsync(file, 0); 942d911df7bSJ. Bruce Fields } 943d911df7bSJ. Bruce Fields last_ino = inode->i_ino; 944d911df7bSJ. Bruce Fields last_dev = inode->i_sb->s_dev; 945d911df7bSJ. Bruce Fields return err; 946d911df7bSJ. Bruce Fields } 947d911df7bSJ. Bruce Fields 9486264d69dSAl Viro static __be32 9491da177e4SLinus Torvalds nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file, 9501da177e4SLinus Torvalds loff_t offset, struct kvec *vec, int vlen, 95131dec253SDavid Shaw unsigned long *cnt, int *stablep) 9521da177e4SLinus Torvalds { 9531da177e4SLinus Torvalds struct svc_export *exp; 9541da177e4SLinus Torvalds struct inode *inode; 9551da177e4SLinus Torvalds mm_segment_t oldfs; 9566264d69dSAl Viro __be32 err = 0; 9576264d69dSAl Viro int host_err; 9581da177e4SLinus Torvalds int stable = *stablep; 95948e03bc5STrond Myklebust int use_wgather; 960e49dbbf3SKent Overstreet loff_t pos = offset; 961e77a7b4fSZach Brown loff_t end = LLONG_MAX; 9628658452eSNeilBrown unsigned int pflags = current->flags; 9638658452eSNeilBrown 9647501cc2bSJeff Layton if (test_bit(RQ_LOCAL, &rqstp->rq_flags)) 9658658452eSNeilBrown /* 9668658452eSNeilBrown * We want less throttling in balance_dirty_pages() 9678658452eSNeilBrown * and shrink_inactive_list() so that nfs to 9688658452eSNeilBrown * localhost doesn't cause nfsd to lock up due to all 9698658452eSNeilBrown * the client's dirty pages or its congested queue. 9708658452eSNeilBrown */ 9718658452eSNeilBrown current->flags |= PF_LESS_THROTTLE; 9721da177e4SLinus Torvalds 9736f4e0d5aSAl Viro inode = file_inode(file); 9741da177e4SLinus Torvalds exp = fhp->fh_export; 9751da177e4SLinus Torvalds 97648e03bc5STrond Myklebust use_wgather = (rqstp->rq_vers == 2) && EX_WGATHER(exp); 9771da177e4SLinus Torvalds 9781da177e4SLinus Torvalds if (!EX_ISSYNC(exp)) 9791da177e4SLinus Torvalds stable = 0; 9801da177e4SLinus Torvalds 9811da177e4SLinus Torvalds /* Write the data. */ 9821da177e4SLinus Torvalds oldfs = get_fs(); set_fs(KERNEL_DS); 983e49dbbf3SKent Overstreet host_err = vfs_writev(file, (struct iovec __user *)vec, vlen, &pos); 9841da177e4SLinus Torvalds set_fs(oldfs); 985e4636d53SJ. Bruce Fields if (host_err < 0) 986e4636d53SJ. Bruce Fields goto out_nfserr; 987a0d24b29SWei Yongjun *cnt = host_err; 98831dec253SDavid Shaw nfsdstats.io_write += host_err; 9892a12a9d7SEric Paris fsnotify_modify(file); 9901da177e4SLinus Torvalds 991face1502SJ. Bruce Fields if (stable) { 992e77a7b4fSZach Brown if (use_wgather) { 993d911df7bSJ. Bruce Fields host_err = wait_for_concurrent_writes(file); 994e77a7b4fSZach Brown } else { 995e77a7b4fSZach Brown if (*cnt) 996e77a7b4fSZach Brown end = offset + *cnt - 1; 997e77a7b4fSZach Brown host_err = vfs_fsync_range(file, offset, end, 0); 998e77a7b4fSZach Brown } 999face1502SJ. Bruce Fields } 10001da177e4SLinus Torvalds 1001e4636d53SJ. Bruce Fields out_nfserr: 10026264d69dSAl Viro dprintk("nfsd: write complete host_err=%d\n", host_err); 1003a0d24b29SWei Yongjun if (host_err >= 0) 10041da177e4SLinus Torvalds err = 0; 1005a0d24b29SWei Yongjun else 10066264d69dSAl Viro err = nfserrno(host_err); 10077501cc2bSJeff Layton if (test_bit(RQ_LOCAL, &rqstp->rq_flags)) 10088658452eSNeilBrown tsk_restore_flags(current, pflags, PF_LESS_THROTTLE); 10091da177e4SLinus Torvalds return err; 10101da177e4SLinus Torvalds } 10111da177e4SLinus Torvalds 1012dc97618dSJ. Bruce Fields __be32 nfsd_get_tmp_read_open(struct svc_rqst *rqstp, struct svc_fh *fhp, 1013dc97618dSJ. Bruce Fields struct file **file, struct raparms **ra) 1014fa0a2126SJ. Bruce Fields { 1015fa0a2126SJ. Bruce Fields struct inode *inode; 1016fa0a2126SJ. Bruce Fields __be32 err; 1017fa0a2126SJ. Bruce Fields 1018dc97618dSJ. Bruce Fields err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, file); 1019fa0a2126SJ. Bruce Fields if (err) 1020fa0a2126SJ. Bruce Fields return err; 1021fa0a2126SJ. Bruce Fields 1022dc97618dSJ. Bruce Fields inode = file_inode(*file); 1023fa0a2126SJ. Bruce Fields 1024fa0a2126SJ. Bruce Fields /* Get readahead parameters */ 1025dc97618dSJ. Bruce Fields *ra = nfsd_get_raparms(inode->i_sb->s_dev, inode->i_ino); 1026fa0a2126SJ. Bruce Fields 1027dc97618dSJ. Bruce Fields if (*ra && (*ra)->p_set) 1028dc97618dSJ. Bruce Fields (*file)->f_ra = (*ra)->p_ra; 1029dc97618dSJ. Bruce Fields return nfs_ok; 1030dc97618dSJ. Bruce Fields } 1031fa0a2126SJ. Bruce Fields 1032dc97618dSJ. Bruce Fields void nfsd_put_tmp_read_open(struct file *file, struct raparms *ra) 1033dc97618dSJ. Bruce Fields { 1034fa0a2126SJ. Bruce Fields /* Write back readahead params */ 1035fa0a2126SJ. Bruce Fields if (ra) { 1036fa0a2126SJ. Bruce Fields struct raparm_hbucket *rab = &raparm_hash[ra->p_hindex]; 1037fa0a2126SJ. Bruce Fields spin_lock(&rab->pb_lock); 1038fa0a2126SJ. Bruce Fields ra->p_ra = file->f_ra; 1039fa0a2126SJ. Bruce Fields ra->p_set = 1; 1040fa0a2126SJ. Bruce Fields ra->p_count--; 1041fa0a2126SJ. Bruce Fields spin_unlock(&rab->pb_lock); 1042fa0a2126SJ. Bruce Fields } 1043fa0a2126SJ. Bruce Fields nfsd_close(file); 1044dc97618dSJ. Bruce Fields } 1045dc97618dSJ. Bruce Fields 1046dc97618dSJ. Bruce Fields /* 1047dc97618dSJ. Bruce Fields * Read data from a file. count must contain the requested read count 1048dc97618dSJ. Bruce Fields * on entry. On return, *count contains the number of bytes actually read. 1049dc97618dSJ. Bruce Fields * N.B. After this call fhp needs an fh_put 1050dc97618dSJ. Bruce Fields */ 1051dc97618dSJ. Bruce Fields __be32 nfsd_read(struct svc_rqst *rqstp, struct svc_fh *fhp, 1052dc97618dSJ. Bruce Fields loff_t offset, struct kvec *vec, int vlen, unsigned long *count) 1053dc97618dSJ. Bruce Fields { 1054dc97618dSJ. Bruce Fields struct file *file; 1055dc97618dSJ. Bruce Fields struct raparms *ra; 1056dc97618dSJ. Bruce Fields __be32 err; 1057dc97618dSJ. Bruce Fields 1058dc97618dSJ. Bruce Fields err = nfsd_get_tmp_read_open(rqstp, fhp, &file, &ra); 1059dc97618dSJ. Bruce Fields if (err) 1060dc97618dSJ. Bruce Fields return err; 1061dc97618dSJ. Bruce Fields 1062dc97618dSJ. Bruce Fields err = nfsd_vfs_read(rqstp, file, offset, vec, vlen, count); 1063dc97618dSJ. Bruce Fields 1064dc97618dSJ. Bruce Fields nfsd_put_tmp_read_open(file, ra); 1065dc97618dSJ. Bruce Fields 1066fa0a2126SJ. Bruce Fields return err; 1067fa0a2126SJ. Bruce Fields } 1068fa0a2126SJ. Bruce Fields 10691da177e4SLinus Torvalds /* 10701da177e4SLinus Torvalds * Write data to a file. 10711da177e4SLinus Torvalds * The stable flag requests synchronous writes. 10721da177e4SLinus Torvalds * N.B. After this call fhp needs an fh_put 10731da177e4SLinus Torvalds */ 10746264d69dSAl Viro __be32 10751da177e4SLinus Torvalds nfsd_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file, 107631dec253SDavid Shaw loff_t offset, struct kvec *vec, int vlen, unsigned long *cnt, 10771da177e4SLinus Torvalds int *stablep) 10781da177e4SLinus Torvalds { 10796264d69dSAl Viro __be32 err = 0; 10801da177e4SLinus Torvalds 10811da177e4SLinus Torvalds if (file) { 10820ec757dfSJ. Bruce Fields err = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry, 10838837abcaSMiklos Szeredi NFSD_MAY_WRITE|NFSD_MAY_OWNER_OVERRIDE); 10841da177e4SLinus Torvalds if (err) 10851da177e4SLinus Torvalds goto out; 10861da177e4SLinus Torvalds err = nfsd_vfs_write(rqstp, fhp, file, offset, vec, vlen, cnt, 10871da177e4SLinus Torvalds stablep); 10881da177e4SLinus Torvalds } else { 10898837abcaSMiklos Szeredi err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_WRITE, &file); 10901da177e4SLinus Torvalds if (err) 10911da177e4SLinus Torvalds goto out; 10921da177e4SLinus Torvalds 10931da177e4SLinus Torvalds if (cnt) 10941da177e4SLinus Torvalds err = nfsd_vfs_write(rqstp, fhp, file, offset, vec, vlen, 10951da177e4SLinus Torvalds cnt, stablep); 10961da177e4SLinus Torvalds nfsd_close(file); 10971da177e4SLinus Torvalds } 10981da177e4SLinus Torvalds out: 10991da177e4SLinus Torvalds return err; 11001da177e4SLinus Torvalds } 11011da177e4SLinus Torvalds 11021da177e4SLinus Torvalds #ifdef CONFIG_NFSD_V3 11031da177e4SLinus Torvalds /* 11041da177e4SLinus Torvalds * Commit all pending writes to stable storage. 1105aa696a6fSTrond Myklebust * 1106aa696a6fSTrond Myklebust * Note: we only guarantee that data that lies within the range specified 1107aa696a6fSTrond Myklebust * by the 'offset' and 'count' parameters will be synced. 11081da177e4SLinus Torvalds * 11091da177e4SLinus Torvalds * Unfortunately we cannot lock the file to make sure we return full WCC 11101da177e4SLinus Torvalds * data to the client, as locking happens lower down in the filesystem. 11111da177e4SLinus Torvalds */ 11126264d69dSAl Viro __be32 11131da177e4SLinus Torvalds nfsd_commit(struct svc_rqst *rqstp, struct svc_fh *fhp, 11141da177e4SLinus Torvalds loff_t offset, unsigned long count) 11151da177e4SLinus Torvalds { 11161da177e4SLinus Torvalds struct file *file; 1117aa696a6fSTrond Myklebust loff_t end = LLONG_MAX; 1118aa696a6fSTrond Myklebust __be32 err = nfserr_inval; 11191da177e4SLinus Torvalds 1120aa696a6fSTrond Myklebust if (offset < 0) 1121aa696a6fSTrond Myklebust goto out; 1122aa696a6fSTrond Myklebust if (count != 0) { 1123aa696a6fSTrond Myklebust end = offset + (loff_t)count - 1; 1124aa696a6fSTrond Myklebust if (end < offset) 1125aa696a6fSTrond Myklebust goto out; 1126aa696a6fSTrond Myklebust } 11271da177e4SLinus Torvalds 112891885258SJeff Layton err = nfsd_open(rqstp, fhp, S_IFREG, 112991885258SJeff Layton NFSD_MAY_WRITE|NFSD_MAY_NOT_BREAK_LEASE, &file); 11308837abcaSMiklos Szeredi if (err) 1131aa696a6fSTrond Myklebust goto out; 11321da177e4SLinus Torvalds if (EX_ISSYNC(fhp->fh_export)) { 11338018ab05SChristoph Hellwig int err2 = vfs_fsync_range(file, offset, end, 0); 1134aa696a6fSTrond Myklebust 1135aa696a6fSTrond Myklebust if (err2 != -EINVAL) 1136aa696a6fSTrond Myklebust err = nfserrno(err2); 1137aa696a6fSTrond Myklebust else 11381da177e4SLinus Torvalds err = nfserr_notsupp; 11391da177e4SLinus Torvalds } 11401da177e4SLinus Torvalds 11411da177e4SLinus Torvalds nfsd_close(file); 1142aa696a6fSTrond Myklebust out: 11431da177e4SLinus Torvalds return err; 11441da177e4SLinus Torvalds } 11451da177e4SLinus Torvalds #endif /* CONFIG_NFSD_V3 */ 11461da177e4SLinus Torvalds 1147f2b0dee2SAdrian Bunk static __be32 11485c002b3bSJ. Bruce Fields nfsd_create_setattr(struct svc_rqst *rqstp, struct svc_fh *resfhp, 11495c002b3bSJ. Bruce Fields struct iattr *iap) 11505c002b3bSJ. Bruce Fields { 11515c002b3bSJ. Bruce Fields /* 11525c002b3bSJ. Bruce Fields * Mode has already been set earlier in create: 11535c002b3bSJ. Bruce Fields */ 11545c002b3bSJ. Bruce Fields iap->ia_valid &= ~ATTR_MODE; 11555c002b3bSJ. Bruce Fields /* 11565c002b3bSJ. Bruce Fields * Setting uid/gid works only for root. Irix appears to 11575c002b3bSJ. Bruce Fields * send along the gid on create when it tries to implement 11585c002b3bSJ. Bruce Fields * setgid directories via NFS: 11595c002b3bSJ. Bruce Fields */ 11606fab8779SEric W. Biederman if (!uid_eq(current_fsuid(), GLOBAL_ROOT_UID)) 11615c002b3bSJ. Bruce Fields iap->ia_valid &= ~(ATTR_UID|ATTR_GID); 11625c002b3bSJ. Bruce Fields if (iap->ia_valid) 11635c002b3bSJ. Bruce Fields return nfsd_setattr(rqstp, resfhp, iap, 0, (time_t)0); 11640f3a24b4STrond Myklebust /* Callers expect file metadata to be committed here */ 1165722b620dSJeff Layton return nfserrno(commit_metadata(resfhp)); 11665c002b3bSJ. Bruce Fields } 11675c002b3bSJ. Bruce Fields 11684ac35c2fSwengang wang /* HPUX client sometimes creates a file in mode 000, and sets size to 0. 11694ac35c2fSwengang wang * setting size to 0 may fail for some specific file systems by the permission 11704ac35c2fSwengang wang * checking which requires WRITE permission but the mode is 000. 11714ac35c2fSwengang wang * we ignore the resizing(to 0) on the just new created file, since the size is 11724ac35c2fSwengang wang * 0 after file created. 11734ac35c2fSwengang wang * 11744ac35c2fSwengang wang * call this only after vfs_create() is called. 11754ac35c2fSwengang wang * */ 11764ac35c2fSwengang wang static void 11774ac35c2fSwengang wang nfsd_check_ignore_resizing(struct iattr *iap) 11784ac35c2fSwengang wang { 11794ac35c2fSwengang wang if ((iap->ia_valid & ATTR_SIZE) && (iap->ia_size == 0)) 11804ac35c2fSwengang wang iap->ia_valid &= ~ATTR_SIZE; 11814ac35c2fSwengang wang } 11824ac35c2fSwengang wang 11831da177e4SLinus Torvalds /* 11841da177e4SLinus Torvalds * Create a file (regular, directory, device, fifo); UNIX sockets 11851da177e4SLinus Torvalds * not yet implemented. 11861da177e4SLinus Torvalds * If the response fh has been verified, the parent directory should 11871da177e4SLinus Torvalds * already be locked. Note that the parent directory is left locked. 11881da177e4SLinus Torvalds * 11891da177e4SLinus Torvalds * N.B. Every call to nfsd_create needs an fh_put for _both_ fhp and resfhp 11901da177e4SLinus Torvalds */ 11916264d69dSAl Viro __be32 11921da177e4SLinus Torvalds nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp, 11931da177e4SLinus Torvalds char *fname, int flen, struct iattr *iap, 11941da177e4SLinus Torvalds int type, dev_t rdev, struct svc_fh *resfhp) 11951da177e4SLinus Torvalds { 11961da177e4SLinus Torvalds struct dentry *dentry, *dchild = NULL; 11971da177e4SLinus Torvalds struct inode *dirp; 11986264d69dSAl Viro __be32 err; 11995c002b3bSJ. Bruce Fields __be32 err2; 12006264d69dSAl Viro int host_err; 12011da177e4SLinus Torvalds 12021da177e4SLinus Torvalds err = nfserr_perm; 12031da177e4SLinus Torvalds if (!flen) 12041da177e4SLinus Torvalds goto out; 12051da177e4SLinus Torvalds err = nfserr_exist; 12061da177e4SLinus Torvalds if (isdotent(fname, flen)) 12071da177e4SLinus Torvalds goto out; 12081da177e4SLinus Torvalds 12098837abcaSMiklos Szeredi err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE); 12101da177e4SLinus Torvalds if (err) 12111da177e4SLinus Torvalds goto out; 12121da177e4SLinus Torvalds 12131da177e4SLinus Torvalds dentry = fhp->fh_dentry; 1214*2b0143b5SDavid Howells dirp = d_inode(dentry); 12151da177e4SLinus Torvalds 12161da177e4SLinus Torvalds err = nfserr_notdir; 1217acfa4380SAl Viro if (!dirp->i_op->lookup) 12181da177e4SLinus Torvalds goto out; 12191da177e4SLinus Torvalds /* 12201da177e4SLinus Torvalds * Check whether the response file handle has been verified yet. 12211da177e4SLinus Torvalds * If it has, the parent directory should already be locked. 12221da177e4SLinus Torvalds */ 12231da177e4SLinus Torvalds if (!resfhp->fh_dentry) { 12244a55c101SJan Kara host_err = fh_want_write(fhp); 12254a55c101SJan Kara if (host_err) 12264a55c101SJan Kara goto out_nfserr; 12274a55c101SJan Kara 12281da177e4SLinus Torvalds /* called from nfsd_proc_mkdir, or possibly nfsd3_proc_create */ 122912fd3520SPeter Zijlstra fh_lock_nested(fhp, I_MUTEX_PARENT); 12301da177e4SLinus Torvalds dchild = lookup_one_len(fname, dentry, flen); 12316264d69dSAl Viro host_err = PTR_ERR(dchild); 12321da177e4SLinus Torvalds if (IS_ERR(dchild)) 12331da177e4SLinus Torvalds goto out_nfserr; 12341da177e4SLinus Torvalds err = fh_compose(resfhp, fhp->fh_export, dchild, fhp); 12351da177e4SLinus Torvalds if (err) 12361da177e4SLinus Torvalds goto out; 12371da177e4SLinus Torvalds } else { 12381da177e4SLinus Torvalds /* called from nfsd_proc_create */ 12391da177e4SLinus Torvalds dchild = dget(resfhp->fh_dentry); 12401da177e4SLinus Torvalds if (!fhp->fh_locked) { 12411da177e4SLinus Torvalds /* not actually possible */ 12421da177e4SLinus Torvalds printk(KERN_ERR 1243a6a9f18fSAl Viro "nfsd_create: parent %pd2 not locked!\n", 1244a6a9f18fSAl Viro dentry); 1245d75f2b9fSAl Viro err = nfserr_io; 12461da177e4SLinus Torvalds goto out; 12471da177e4SLinus Torvalds } 12481da177e4SLinus Torvalds } 12491da177e4SLinus Torvalds /* 12501da177e4SLinus Torvalds * Make sure the child dentry is still negative ... 12511da177e4SLinus Torvalds */ 12521da177e4SLinus Torvalds err = nfserr_exist; 1253*2b0143b5SDavid Howells if (d_really_is_positive(dchild)) { 1254a6a9f18fSAl Viro dprintk("nfsd_create: dentry %pd/%pd not negative!\n", 1255a6a9f18fSAl Viro dentry, dchild); 12561da177e4SLinus Torvalds goto out; 12571da177e4SLinus Torvalds } 12581da177e4SLinus Torvalds 12591da177e4SLinus Torvalds if (!(iap->ia_valid & ATTR_MODE)) 12601da177e4SLinus Torvalds iap->ia_mode = 0; 12611da177e4SLinus Torvalds iap->ia_mode = (iap->ia_mode & S_IALLUGO) | type; 12621da177e4SLinus Torvalds 126307cad1d2SMiklos Szeredi err = nfserr_inval; 126407cad1d2SMiklos Szeredi if (!S_ISREG(type) && !S_ISDIR(type) && !special_file(type)) { 126507cad1d2SMiklos Szeredi printk(KERN_WARNING "nfsd: bad file type %o in nfsd_create\n", 126607cad1d2SMiklos Szeredi type); 126707cad1d2SMiklos Szeredi goto out; 126807cad1d2SMiklos Szeredi } 126907cad1d2SMiklos Szeredi 12701da177e4SLinus Torvalds /* 12711da177e4SLinus Torvalds * Get the dir op function pointer. 12721da177e4SLinus Torvalds */ 1273088406bcSJ. Bruce Fields err = 0; 12744a55c101SJan Kara host_err = 0; 12751da177e4SLinus Torvalds switch (type) { 12761da177e4SLinus Torvalds case S_IFREG: 1277312b63fbSAl Viro host_err = vfs_create(dirp, dchild, iap->ia_mode, true); 12784ac35c2fSwengang wang if (!host_err) 12794ac35c2fSwengang wang nfsd_check_ignore_resizing(iap); 12801da177e4SLinus Torvalds break; 12811da177e4SLinus Torvalds case S_IFDIR: 12826264d69dSAl Viro host_err = vfs_mkdir(dirp, dchild, iap->ia_mode); 12831da177e4SLinus Torvalds break; 12841da177e4SLinus Torvalds case S_IFCHR: 12851da177e4SLinus Torvalds case S_IFBLK: 12861da177e4SLinus Torvalds case S_IFIFO: 12871da177e4SLinus Torvalds case S_IFSOCK: 12886264d69dSAl Viro host_err = vfs_mknod(dirp, dchild, iap->ia_mode, rdev); 12891da177e4SLinus Torvalds break; 1290463c3197SDave Hansen } 12914a55c101SJan Kara if (host_err < 0) 1292463c3197SDave Hansen goto out_nfserr; 12931da177e4SLinus Torvalds 1294f501912aSBen Myers err = nfsd_create_setattr(rqstp, resfhp, iap); 12951da177e4SLinus Torvalds 1296f501912aSBen Myers /* 12970f3a24b4STrond Myklebust * nfsd_create_setattr already committed the child. Transactional 12980f3a24b4STrond Myklebust * filesystems had a chance to commit changes for both parent and 12990f3a24b4STrond Myklebust * child * simultaneously making the following commit_metadata a 13000f3a24b4STrond Myklebust * noop. 1301f501912aSBen Myers */ 1302f501912aSBen Myers err2 = nfserrno(commit_metadata(fhp)); 1303f193fbabSYAMAMOTO Takashi if (err2) 1304f193fbabSYAMAMOTO Takashi err = err2; 13051da177e4SLinus Torvalds /* 13061da177e4SLinus Torvalds * Update the file handle to get the new inode info. 13071da177e4SLinus Torvalds */ 13081da177e4SLinus Torvalds if (!err) 13091da177e4SLinus Torvalds err = fh_update(resfhp); 13101da177e4SLinus Torvalds out: 13111da177e4SLinus Torvalds if (dchild && !IS_ERR(dchild)) 13121da177e4SLinus Torvalds dput(dchild); 13131da177e4SLinus Torvalds return err; 13141da177e4SLinus Torvalds 13151da177e4SLinus Torvalds out_nfserr: 13166264d69dSAl Viro err = nfserrno(host_err); 13171da177e4SLinus Torvalds goto out; 13181da177e4SLinus Torvalds } 13191da177e4SLinus Torvalds 13201da177e4SLinus Torvalds #ifdef CONFIG_NFSD_V3 1321ac6721a1SMi Jinlong 1322ac6721a1SMi Jinlong static inline int nfsd_create_is_exclusive(int createmode) 1323ac6721a1SMi Jinlong { 1324ac6721a1SMi Jinlong return createmode == NFS3_CREATE_EXCLUSIVE 1325ac6721a1SMi Jinlong || createmode == NFS4_CREATE_EXCLUSIVE4_1; 1326ac6721a1SMi Jinlong } 1327ac6721a1SMi Jinlong 13281da177e4SLinus Torvalds /* 1329ac6721a1SMi Jinlong * NFSv3 and NFSv4 version of nfsd_create 13301da177e4SLinus Torvalds */ 13316264d69dSAl Viro __be32 1332ac6721a1SMi Jinlong do_nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp, 13331da177e4SLinus Torvalds char *fname, int flen, struct iattr *iap, 13341da177e4SLinus Torvalds struct svc_fh *resfhp, int createmode, u32 *verifier, 1335856121b2SJ. Bruce Fields bool *truncp, bool *created) 13361da177e4SLinus Torvalds { 13371da177e4SLinus Torvalds struct dentry *dentry, *dchild = NULL; 13381da177e4SLinus Torvalds struct inode *dirp; 13396264d69dSAl Viro __be32 err; 13406264d69dSAl Viro int host_err; 13411da177e4SLinus Torvalds __u32 v_mtime=0, v_atime=0; 13421da177e4SLinus Torvalds 13431da177e4SLinus Torvalds err = nfserr_perm; 13441da177e4SLinus Torvalds if (!flen) 13451da177e4SLinus Torvalds goto out; 13461da177e4SLinus Torvalds err = nfserr_exist; 13471da177e4SLinus Torvalds if (isdotent(fname, flen)) 13481da177e4SLinus Torvalds goto out; 13491da177e4SLinus Torvalds if (!(iap->ia_valid & ATTR_MODE)) 13501da177e4SLinus Torvalds iap->ia_mode = 0; 13511574dff8SSachin Prabhu err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_EXEC); 13521da177e4SLinus Torvalds if (err) 13531da177e4SLinus Torvalds goto out; 13541da177e4SLinus Torvalds 13551da177e4SLinus Torvalds dentry = fhp->fh_dentry; 1356*2b0143b5SDavid Howells dirp = d_inode(dentry); 13571da177e4SLinus Torvalds 13581da177e4SLinus Torvalds /* Get all the sanity checks out of the way before 13591da177e4SLinus Torvalds * we lock the parent. */ 13601da177e4SLinus Torvalds err = nfserr_notdir; 1361acfa4380SAl Viro if (!dirp->i_op->lookup) 13621da177e4SLinus Torvalds goto out; 13634a55c101SJan Kara 13644a55c101SJan Kara host_err = fh_want_write(fhp); 13654a55c101SJan Kara if (host_err) 13664a55c101SJan Kara goto out_nfserr; 13674a55c101SJan Kara 136812fd3520SPeter Zijlstra fh_lock_nested(fhp, I_MUTEX_PARENT); 13691da177e4SLinus Torvalds 13701da177e4SLinus Torvalds /* 13711da177e4SLinus Torvalds * Compose the response file handle. 13721da177e4SLinus Torvalds */ 13731da177e4SLinus Torvalds dchild = lookup_one_len(fname, dentry, flen); 13746264d69dSAl Viro host_err = PTR_ERR(dchild); 13751da177e4SLinus Torvalds if (IS_ERR(dchild)) 13761da177e4SLinus Torvalds goto out_nfserr; 13771da177e4SLinus Torvalds 13781574dff8SSachin Prabhu /* If file doesn't exist, check for permissions to create one */ 1379*2b0143b5SDavid Howells if (d_really_is_negative(dchild)) { 13801574dff8SSachin Prabhu err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE); 13811574dff8SSachin Prabhu if (err) 13821574dff8SSachin Prabhu goto out; 13831574dff8SSachin Prabhu } 13841574dff8SSachin Prabhu 13851da177e4SLinus Torvalds err = fh_compose(resfhp, fhp->fh_export, dchild, fhp); 13861da177e4SLinus Torvalds if (err) 13871da177e4SLinus Torvalds goto out; 13881da177e4SLinus Torvalds 1389ac6721a1SMi Jinlong if (nfsd_create_is_exclusive(createmode)) { 1390c397852cSPeter Staubach /* solaris7 gets confused (bugid 4218508) if these have 1391749997e5SJeff Layton * the high bit set, so just clear the high bits. If this is 1392749997e5SJeff Layton * ever changed to use different attrs for storing the 1393749997e5SJeff Layton * verifier, then do_open_lookup() will also need to be fixed 1394749997e5SJeff Layton * accordingly. 13951da177e4SLinus Torvalds */ 13961da177e4SLinus Torvalds v_mtime = verifier[0]&0x7fffffff; 13971da177e4SLinus Torvalds v_atime = verifier[1]&0x7fffffff; 13981da177e4SLinus Torvalds } 13991da177e4SLinus Torvalds 1400*2b0143b5SDavid Howells if (d_really_is_positive(dchild)) { 14011da177e4SLinus Torvalds err = 0; 14021da177e4SLinus Torvalds 14031da177e4SLinus Torvalds switch (createmode) { 14041da177e4SLinus Torvalds case NFS3_CREATE_UNCHECKED: 1405e36cb0b8SDavid Howells if (! d_is_reg(dchild)) 14069dc4e6c4SJ. Bruce Fields goto out; 14071da177e4SLinus Torvalds else if (truncp) { 14081da177e4SLinus Torvalds /* in nfsv4, we need to treat this case a little 14091da177e4SLinus Torvalds * differently. we don't want to truncate the 14101da177e4SLinus Torvalds * file now; this would be wrong if the OPEN 14111da177e4SLinus Torvalds * fails for some other reason. furthermore, 14121da177e4SLinus Torvalds * if the size is nonzero, we should ignore it 14131da177e4SLinus Torvalds * according to spec! 14141da177e4SLinus Torvalds */ 14151da177e4SLinus Torvalds *truncp = (iap->ia_valid & ATTR_SIZE) && !iap->ia_size; 14161da177e4SLinus Torvalds } 14171da177e4SLinus Torvalds else { 14181da177e4SLinus Torvalds iap->ia_valid &= ATTR_SIZE; 14191da177e4SLinus Torvalds goto set_attr; 14201da177e4SLinus Torvalds } 14211da177e4SLinus Torvalds break; 14221da177e4SLinus Torvalds case NFS3_CREATE_EXCLUSIVE: 1423*2b0143b5SDavid Howells if ( d_inode(dchild)->i_mtime.tv_sec == v_mtime 1424*2b0143b5SDavid Howells && d_inode(dchild)->i_atime.tv_sec == v_atime 1425*2b0143b5SDavid Howells && d_inode(dchild)->i_size == 0 ) { 14267007c90fSNeil Brown if (created) 14277007c90fSNeil Brown *created = 1; 14281da177e4SLinus Torvalds break; 14297007c90fSNeil Brown } 1430ac6721a1SMi Jinlong case NFS4_CREATE_EXCLUSIVE4_1: 1431*2b0143b5SDavid Howells if ( d_inode(dchild)->i_mtime.tv_sec == v_mtime 1432*2b0143b5SDavid Howells && d_inode(dchild)->i_atime.tv_sec == v_atime 1433*2b0143b5SDavid Howells && d_inode(dchild)->i_size == 0 ) { 14347007c90fSNeil Brown if (created) 14357007c90fSNeil Brown *created = 1; 1436ac6721a1SMi Jinlong goto set_attr; 14377007c90fSNeil Brown } 14381da177e4SLinus Torvalds /* fallthru */ 14391da177e4SLinus Torvalds case NFS3_CREATE_GUARDED: 14401da177e4SLinus Torvalds err = nfserr_exist; 14411da177e4SLinus Torvalds } 1442bad0dcffSAl Viro fh_drop_write(fhp); 14431da177e4SLinus Torvalds goto out; 14441da177e4SLinus Torvalds } 14451da177e4SLinus Torvalds 1446312b63fbSAl Viro host_err = vfs_create(dirp, dchild, iap->ia_mode, true); 1447463c3197SDave Hansen if (host_err < 0) { 1448bad0dcffSAl Viro fh_drop_write(fhp); 14491da177e4SLinus Torvalds goto out_nfserr; 1450463c3197SDave Hansen } 145181ac95c5SJ. Bruce Fields if (created) 145281ac95c5SJ. Bruce Fields *created = 1; 14531da177e4SLinus Torvalds 14544ac35c2fSwengang wang nfsd_check_ignore_resizing(iap); 14554ac35c2fSwengang wang 1456ac6721a1SMi Jinlong if (nfsd_create_is_exclusive(createmode)) { 1457c397852cSPeter Staubach /* Cram the verifier into atime/mtime */ 14581da177e4SLinus Torvalds iap->ia_valid = ATTR_MTIME|ATTR_ATIME 1459c397852cSPeter Staubach | ATTR_MTIME_SET|ATTR_ATIME_SET; 14601da177e4SLinus Torvalds /* XXX someone who knows this better please fix it for nsec */ 14611da177e4SLinus Torvalds iap->ia_mtime.tv_sec = v_mtime; 14621da177e4SLinus Torvalds iap->ia_atime.tv_sec = v_atime; 14631da177e4SLinus Torvalds iap->ia_mtime.tv_nsec = 0; 14641da177e4SLinus Torvalds iap->ia_atime.tv_nsec = 0; 14651da177e4SLinus Torvalds } 14661da177e4SLinus Torvalds 14671da177e4SLinus Torvalds set_attr: 1468f501912aSBen Myers err = nfsd_create_setattr(rqstp, resfhp, iap); 1469f501912aSBen Myers 1470f501912aSBen Myers /* 14710f3a24b4STrond Myklebust * nfsd_create_setattr already committed the child 14720f3a24b4STrond Myklebust * (and possibly also the parent). 1473f501912aSBen Myers */ 1474f501912aSBen Myers if (!err) 1475f501912aSBen Myers err = nfserrno(commit_metadata(fhp)); 1476f193fbabSYAMAMOTO Takashi 1477f193fbabSYAMAMOTO Takashi /* 1478f193fbabSYAMAMOTO Takashi * Update the filehandle to get the new inode info. 1479f193fbabSYAMAMOTO Takashi */ 1480f193fbabSYAMAMOTO Takashi if (!err) 1481f193fbabSYAMAMOTO Takashi err = fh_update(resfhp); 14821da177e4SLinus Torvalds 14831da177e4SLinus Torvalds out: 14841da177e4SLinus Torvalds fh_unlock(fhp); 14851da177e4SLinus Torvalds if (dchild && !IS_ERR(dchild)) 14861da177e4SLinus Torvalds dput(dchild); 14874a55c101SJan Kara fh_drop_write(fhp); 14881da177e4SLinus Torvalds return err; 14891da177e4SLinus Torvalds 14901da177e4SLinus Torvalds out_nfserr: 14916264d69dSAl Viro err = nfserrno(host_err); 14921da177e4SLinus Torvalds goto out; 14931da177e4SLinus Torvalds } 14941da177e4SLinus Torvalds #endif /* CONFIG_NFSD_V3 */ 14951da177e4SLinus Torvalds 14961da177e4SLinus Torvalds /* 14971da177e4SLinus Torvalds * Read a symlink. On entry, *lenp must contain the maximum path length that 14981da177e4SLinus Torvalds * fits into the buffer. On return, it contains the true length. 14991da177e4SLinus Torvalds * N.B. After this call fhp needs an fh_put 15001da177e4SLinus Torvalds */ 15016264d69dSAl Viro __be32 15021da177e4SLinus Torvalds nfsd_readlink(struct svc_rqst *rqstp, struct svc_fh *fhp, char *buf, int *lenp) 15031da177e4SLinus Torvalds { 15041da177e4SLinus Torvalds struct inode *inode; 15051da177e4SLinus Torvalds mm_segment_t oldfs; 15066264d69dSAl Viro __be32 err; 15076264d69dSAl Viro int host_err; 150868ac1234SAl Viro struct path path; 15091da177e4SLinus Torvalds 15108837abcaSMiklos Szeredi err = fh_verify(rqstp, fhp, S_IFLNK, NFSD_MAY_NOP); 15111da177e4SLinus Torvalds if (err) 15121da177e4SLinus Torvalds goto out; 15131da177e4SLinus Torvalds 151468ac1234SAl Viro path.mnt = fhp->fh_export->ex_path.mnt; 151568ac1234SAl Viro path.dentry = fhp->fh_dentry; 1516*2b0143b5SDavid Howells inode = d_inode(path.dentry); 15171da177e4SLinus Torvalds 15181da177e4SLinus Torvalds err = nfserr_inval; 1519acfa4380SAl Viro if (!inode->i_op->readlink) 15201da177e4SLinus Torvalds goto out; 15211da177e4SLinus Torvalds 152268ac1234SAl Viro touch_atime(&path); 15231da177e4SLinus Torvalds /* N.B. Why does this call need a get_fs()?? 15241da177e4SLinus Torvalds * Remove the set_fs and watch the fireworks:-) --okir 15251da177e4SLinus Torvalds */ 15261da177e4SLinus Torvalds 15271da177e4SLinus Torvalds oldfs = get_fs(); set_fs(KERNEL_DS); 1528fac7a17bSJ. Bruce Fields host_err = inode->i_op->readlink(path.dentry, (char __user *)buf, *lenp); 15291da177e4SLinus Torvalds set_fs(oldfs); 15301da177e4SLinus Torvalds 15316264d69dSAl Viro if (host_err < 0) 15321da177e4SLinus Torvalds goto out_nfserr; 15336264d69dSAl Viro *lenp = host_err; 15341da177e4SLinus Torvalds err = 0; 15351da177e4SLinus Torvalds out: 15361da177e4SLinus Torvalds return err; 15371da177e4SLinus Torvalds 15381da177e4SLinus Torvalds out_nfserr: 15396264d69dSAl Viro err = nfserrno(host_err); 15401da177e4SLinus Torvalds goto out; 15411da177e4SLinus Torvalds } 15421da177e4SLinus Torvalds 15431da177e4SLinus Torvalds /* 15441da177e4SLinus Torvalds * Create a symlink and look up its inode 15451da177e4SLinus Torvalds * N.B. After this call _both_ fhp and resfhp need an fh_put 15461da177e4SLinus Torvalds */ 15476264d69dSAl Viro __be32 15481da177e4SLinus Torvalds nfsd_symlink(struct svc_rqst *rqstp, struct svc_fh *fhp, 15491da177e4SLinus Torvalds char *fname, int flen, 155052ee0433SJ. Bruce Fields char *path, 15511e444f5bSKinglong Mee struct svc_fh *resfhp) 15521da177e4SLinus Torvalds { 15531da177e4SLinus Torvalds struct dentry *dentry, *dnew; 15546264d69dSAl Viro __be32 err, cerr; 15556264d69dSAl Viro int host_err; 15561da177e4SLinus Torvalds 15571da177e4SLinus Torvalds err = nfserr_noent; 155852ee0433SJ. Bruce Fields if (!flen || path[0] == '\0') 15591da177e4SLinus Torvalds goto out; 15601da177e4SLinus Torvalds err = nfserr_exist; 15611da177e4SLinus Torvalds if (isdotent(fname, flen)) 15621da177e4SLinus Torvalds goto out; 15631da177e4SLinus Torvalds 15648837abcaSMiklos Szeredi err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE); 15651da177e4SLinus Torvalds if (err) 15661da177e4SLinus Torvalds goto out; 15674a55c101SJan Kara 15684a55c101SJan Kara host_err = fh_want_write(fhp); 15694a55c101SJan Kara if (host_err) 15704a55c101SJan Kara goto out_nfserr; 15714a55c101SJan Kara 15721da177e4SLinus Torvalds fh_lock(fhp); 15731da177e4SLinus Torvalds dentry = fhp->fh_dentry; 15741da177e4SLinus Torvalds dnew = lookup_one_len(fname, dentry, flen); 15756264d69dSAl Viro host_err = PTR_ERR(dnew); 15761da177e4SLinus Torvalds if (IS_ERR(dnew)) 15771da177e4SLinus Torvalds goto out_nfserr; 15781da177e4SLinus Torvalds 1579*2b0143b5SDavid Howells host_err = vfs_symlink(d_inode(dentry), dnew, path); 15806264d69dSAl Viro err = nfserrno(host_err); 1581f501912aSBen Myers if (!err) 1582f501912aSBen Myers err = nfserrno(commit_metadata(fhp)); 15831da177e4SLinus Torvalds fh_unlock(fhp); 15841da177e4SLinus Torvalds 1585bad0dcffSAl Viro fh_drop_write(fhp); 158675c3f29dSDave Hansen 15871da177e4SLinus Torvalds cerr = fh_compose(resfhp, fhp->fh_export, dnew, fhp); 15881da177e4SLinus Torvalds dput(dnew); 15891da177e4SLinus Torvalds if (err==0) err = cerr; 15901da177e4SLinus Torvalds out: 15911da177e4SLinus Torvalds return err; 15921da177e4SLinus Torvalds 15931da177e4SLinus Torvalds out_nfserr: 15946264d69dSAl Viro err = nfserrno(host_err); 15951da177e4SLinus Torvalds goto out; 15961da177e4SLinus Torvalds } 15971da177e4SLinus Torvalds 15981da177e4SLinus Torvalds /* 15991da177e4SLinus Torvalds * Create a hardlink 16001da177e4SLinus Torvalds * N.B. After this call _both_ ffhp and tfhp need an fh_put 16011da177e4SLinus Torvalds */ 16026264d69dSAl Viro __be32 16031da177e4SLinus Torvalds nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp, 16041da177e4SLinus Torvalds char *name, int len, struct svc_fh *tfhp) 16051da177e4SLinus Torvalds { 16061da177e4SLinus Torvalds struct dentry *ddir, *dnew, *dold; 160755b13354SJ. Bruce Fields struct inode *dirp; 16086264d69dSAl Viro __be32 err; 16096264d69dSAl Viro int host_err; 16101da177e4SLinus Torvalds 16118837abcaSMiklos Szeredi err = fh_verify(rqstp, ffhp, S_IFDIR, NFSD_MAY_CREATE); 16121da177e4SLinus Torvalds if (err) 16131da177e4SLinus Torvalds goto out; 16147d818a7bSJ. Bruce Fields err = fh_verify(rqstp, tfhp, 0, NFSD_MAY_NOP); 16151da177e4SLinus Torvalds if (err) 16161da177e4SLinus Torvalds goto out; 16177d818a7bSJ. Bruce Fields err = nfserr_isdir; 1618e36cb0b8SDavid Howells if (d_is_dir(tfhp->fh_dentry)) 16197d818a7bSJ. Bruce Fields goto out; 16201da177e4SLinus Torvalds err = nfserr_perm; 16211da177e4SLinus Torvalds if (!len) 16221da177e4SLinus Torvalds goto out; 16231da177e4SLinus Torvalds err = nfserr_exist; 16241da177e4SLinus Torvalds if (isdotent(name, len)) 16251da177e4SLinus Torvalds goto out; 16261da177e4SLinus Torvalds 16274a55c101SJan Kara host_err = fh_want_write(tfhp); 16284a55c101SJan Kara if (host_err) { 16294a55c101SJan Kara err = nfserrno(host_err); 16304a55c101SJan Kara goto out; 16314a55c101SJan Kara } 16324a55c101SJan Kara 163312fd3520SPeter Zijlstra fh_lock_nested(ffhp, I_MUTEX_PARENT); 16341da177e4SLinus Torvalds ddir = ffhp->fh_dentry; 1635*2b0143b5SDavid Howells dirp = d_inode(ddir); 16361da177e4SLinus Torvalds 16371da177e4SLinus Torvalds dnew = lookup_one_len(name, ddir, len); 16386264d69dSAl Viro host_err = PTR_ERR(dnew); 16391da177e4SLinus Torvalds if (IS_ERR(dnew)) 16401da177e4SLinus Torvalds goto out_nfserr; 16411da177e4SLinus Torvalds 16421da177e4SLinus Torvalds dold = tfhp->fh_dentry; 16431da177e4SLinus Torvalds 16444795bb37SJ. Bruce Fields err = nfserr_noent; 1645*2b0143b5SDavid Howells if (d_really_is_negative(dold)) 16464a55c101SJan Kara goto out_dput; 1647146a8595SJ. Bruce Fields host_err = vfs_link(dold, dirp, dnew, NULL); 16486264d69dSAl Viro if (!host_err) { 1649f501912aSBen Myers err = nfserrno(commit_metadata(ffhp)); 1650f501912aSBen Myers if (!err) 1651f501912aSBen Myers err = nfserrno(commit_metadata(tfhp)); 16521da177e4SLinus Torvalds } else { 16536264d69dSAl Viro if (host_err == -EXDEV && rqstp->rq_vers == 2) 16541da177e4SLinus Torvalds err = nfserr_acces; 16551da177e4SLinus Torvalds else 16566264d69dSAl Viro err = nfserrno(host_err); 16571da177e4SLinus Torvalds } 165875c3f29dSDave Hansen out_dput: 16591da177e4SLinus Torvalds dput(dnew); 1660270d56e5SDavid M. Richter out_unlock: 1661270d56e5SDavid M. Richter fh_unlock(ffhp); 16624a55c101SJan Kara fh_drop_write(tfhp); 16631da177e4SLinus Torvalds out: 16641da177e4SLinus Torvalds return err; 16651da177e4SLinus Torvalds 16661da177e4SLinus Torvalds out_nfserr: 16676264d69dSAl Viro err = nfserrno(host_err); 1668270d56e5SDavid M. Richter goto out_unlock; 16691da177e4SLinus Torvalds } 16701da177e4SLinus Torvalds 16711da177e4SLinus Torvalds /* 16721da177e4SLinus Torvalds * Rename a file 16731da177e4SLinus Torvalds * N.B. After this call _both_ ffhp and tfhp need an fh_put 16741da177e4SLinus Torvalds */ 16756264d69dSAl Viro __be32 16761da177e4SLinus Torvalds nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen, 16771da177e4SLinus Torvalds struct svc_fh *tfhp, char *tname, int tlen) 16781da177e4SLinus Torvalds { 16791da177e4SLinus Torvalds struct dentry *fdentry, *tdentry, *odentry, *ndentry, *trap; 16801da177e4SLinus Torvalds struct inode *fdir, *tdir; 16816264d69dSAl Viro __be32 err; 16826264d69dSAl Viro int host_err; 16831da177e4SLinus Torvalds 16848837abcaSMiklos Szeredi err = fh_verify(rqstp, ffhp, S_IFDIR, NFSD_MAY_REMOVE); 16851da177e4SLinus Torvalds if (err) 16861da177e4SLinus Torvalds goto out; 16878837abcaSMiklos Szeredi err = fh_verify(rqstp, tfhp, S_IFDIR, NFSD_MAY_CREATE); 16881da177e4SLinus Torvalds if (err) 16891da177e4SLinus Torvalds goto out; 16901da177e4SLinus Torvalds 16911da177e4SLinus Torvalds fdentry = ffhp->fh_dentry; 1692*2b0143b5SDavid Howells fdir = d_inode(fdentry); 16931da177e4SLinus Torvalds 16941da177e4SLinus Torvalds tdentry = tfhp->fh_dentry; 1695*2b0143b5SDavid Howells tdir = d_inode(tdentry); 16961da177e4SLinus Torvalds 16971da177e4SLinus Torvalds err = nfserr_perm; 16981da177e4SLinus Torvalds if (!flen || isdotent(fname, flen) || !tlen || isdotent(tname, tlen)) 16991da177e4SLinus Torvalds goto out; 17001da177e4SLinus Torvalds 17014a55c101SJan Kara host_err = fh_want_write(ffhp); 17024a55c101SJan Kara if (host_err) { 17034a55c101SJan Kara err = nfserrno(host_err); 17044a55c101SJan Kara goto out; 17054a55c101SJan Kara } 17064a55c101SJan Kara 17071da177e4SLinus Torvalds /* cannot use fh_lock as we need deadlock protective ordering 17081da177e4SLinus Torvalds * so do it by hand */ 17091da177e4SLinus Torvalds trap = lock_rename(tdentry, fdentry); 17101da177e4SLinus Torvalds ffhp->fh_locked = tfhp->fh_locked = 1; 17111da177e4SLinus Torvalds fill_pre_wcc(ffhp); 17121da177e4SLinus Torvalds fill_pre_wcc(tfhp); 17131da177e4SLinus Torvalds 17141da177e4SLinus Torvalds odentry = lookup_one_len(fname, fdentry, flen); 17156264d69dSAl Viro host_err = PTR_ERR(odentry); 17161da177e4SLinus Torvalds if (IS_ERR(odentry)) 17171da177e4SLinus Torvalds goto out_nfserr; 17181da177e4SLinus Torvalds 17196264d69dSAl Viro host_err = -ENOENT; 1720*2b0143b5SDavid Howells if (d_really_is_negative(odentry)) 17211da177e4SLinus Torvalds goto out_dput_old; 17226264d69dSAl Viro host_err = -EINVAL; 17231da177e4SLinus Torvalds if (odentry == trap) 17241da177e4SLinus Torvalds goto out_dput_old; 17251da177e4SLinus Torvalds 17261da177e4SLinus Torvalds ndentry = lookup_one_len(tname, tdentry, tlen); 17276264d69dSAl Viro host_err = PTR_ERR(ndentry); 17281da177e4SLinus Torvalds if (IS_ERR(ndentry)) 17291da177e4SLinus Torvalds goto out_dput_old; 17306264d69dSAl Viro host_err = -ENOTEMPTY; 17311da177e4SLinus Torvalds if (ndentry == trap) 17321da177e4SLinus Torvalds goto out_dput_new; 17331da177e4SLinus Torvalds 17349079b1ebSDave Hansen host_err = -EXDEV; 17359079b1ebSDave Hansen if (ffhp->fh_export->ex_path.mnt != tfhp->fh_export->ex_path.mnt) 17369079b1ebSDave Hansen goto out_dput_new; 1737aa387d6cSJ. Bruce Fields if (ffhp->fh_export->ex_path.dentry != tfhp->fh_export->ex_path.dentry) 1738aa387d6cSJ. Bruce Fields goto out_dput_new; 17399079b1ebSDave Hansen 1740520c8b16SMiklos Szeredi host_err = vfs_rename(fdir, odentry, tdir, ndentry, NULL, 0); 1741f501912aSBen Myers if (!host_err) { 1742f501912aSBen Myers host_err = commit_metadata(tfhp); 17436264d69dSAl Viro if (!host_err) 1744f501912aSBen Myers host_err = commit_metadata(ffhp); 17451da177e4SLinus Torvalds } 17461da177e4SLinus Torvalds out_dput_new: 17471da177e4SLinus Torvalds dput(ndentry); 17481da177e4SLinus Torvalds out_dput_old: 17491da177e4SLinus Torvalds dput(odentry); 17501da177e4SLinus Torvalds out_nfserr: 17516264d69dSAl Viro err = nfserrno(host_err); 1752fbb74a34SJ. Bruce Fields /* 1753fbb74a34SJ. Bruce Fields * We cannot rely on fh_unlock on the two filehandles, 17541da177e4SLinus Torvalds * as that would do the wrong thing if the two directories 1755fbb74a34SJ. Bruce Fields * were the same, so again we do it by hand. 17561da177e4SLinus Torvalds */ 17571da177e4SLinus Torvalds fill_post_wcc(ffhp); 17581da177e4SLinus Torvalds fill_post_wcc(tfhp); 17591da177e4SLinus Torvalds unlock_rename(tdentry, fdentry); 17601da177e4SLinus Torvalds ffhp->fh_locked = tfhp->fh_locked = 0; 17614a55c101SJan Kara fh_drop_write(ffhp); 17621da177e4SLinus Torvalds 17631da177e4SLinus Torvalds out: 17641da177e4SLinus Torvalds return err; 17651da177e4SLinus Torvalds } 17661da177e4SLinus Torvalds 17671da177e4SLinus Torvalds /* 17681da177e4SLinus Torvalds * Unlink a file or directory 17691da177e4SLinus Torvalds * N.B. After this call fhp needs an fh_put 17701da177e4SLinus Torvalds */ 17716264d69dSAl Viro __be32 17721da177e4SLinus Torvalds nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type, 17731da177e4SLinus Torvalds char *fname, int flen) 17741da177e4SLinus Torvalds { 17751da177e4SLinus Torvalds struct dentry *dentry, *rdentry; 17761da177e4SLinus Torvalds struct inode *dirp; 17776264d69dSAl Viro __be32 err; 17786264d69dSAl Viro int host_err; 17791da177e4SLinus Torvalds 17801da177e4SLinus Torvalds err = nfserr_acces; 17811da177e4SLinus Torvalds if (!flen || isdotent(fname, flen)) 17821da177e4SLinus Torvalds goto out; 17838837abcaSMiklos Szeredi err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_REMOVE); 17841da177e4SLinus Torvalds if (err) 17851da177e4SLinus Torvalds goto out; 17861da177e4SLinus Torvalds 17874a55c101SJan Kara host_err = fh_want_write(fhp); 17884a55c101SJan Kara if (host_err) 17894a55c101SJan Kara goto out_nfserr; 17904a55c101SJan Kara 179112fd3520SPeter Zijlstra fh_lock_nested(fhp, I_MUTEX_PARENT); 17921da177e4SLinus Torvalds dentry = fhp->fh_dentry; 1793*2b0143b5SDavid Howells dirp = d_inode(dentry); 17941da177e4SLinus Torvalds 17951da177e4SLinus Torvalds rdentry = lookup_one_len(fname, dentry, flen); 17966264d69dSAl Viro host_err = PTR_ERR(rdentry); 17971da177e4SLinus Torvalds if (IS_ERR(rdentry)) 17981da177e4SLinus Torvalds goto out_nfserr; 17991da177e4SLinus Torvalds 1800*2b0143b5SDavid Howells if (d_really_is_negative(rdentry)) { 18011da177e4SLinus Torvalds dput(rdentry); 18021da177e4SLinus Torvalds err = nfserr_noent; 18031da177e4SLinus Torvalds goto out; 18041da177e4SLinus Torvalds } 18051da177e4SLinus Torvalds 18061da177e4SLinus Torvalds if (!type) 1807*2b0143b5SDavid Howells type = d_inode(rdentry)->i_mode & S_IFMT; 18081da177e4SLinus Torvalds 18099ce137eeSJ. Bruce Fields if (type != S_IFDIR) 1810b21996e3SJ. Bruce Fields host_err = vfs_unlink(dirp, rdentry, NULL); 18119ce137eeSJ. Bruce Fields else 18126264d69dSAl Viro host_err = vfs_rmdir(dirp, rdentry); 1813541ce98cSJ. Bruce Fields if (!host_err) 1814541ce98cSJ. Bruce Fields host_err = commit_metadata(fhp); 18151da177e4SLinus Torvalds dput(rdentry); 18161da177e4SLinus Torvalds 18171da177e4SLinus Torvalds out_nfserr: 18186264d69dSAl Viro err = nfserrno(host_err); 1819f193fbabSYAMAMOTO Takashi out: 1820f193fbabSYAMAMOTO Takashi return err; 18211da177e4SLinus Torvalds } 18221da177e4SLinus Torvalds 18231da177e4SLinus Torvalds /* 182414f7dd63SDavid Woodhouse * We do this buffering because we must not call back into the file 182514f7dd63SDavid Woodhouse * system's ->lookup() method from the filldir callback. That may well 182614f7dd63SDavid Woodhouse * deadlock a number of file systems. 182714f7dd63SDavid Woodhouse * 182814f7dd63SDavid Woodhouse * This is based heavily on the implementation of same in XFS. 182914f7dd63SDavid Woodhouse */ 183014f7dd63SDavid Woodhouse struct buffered_dirent { 183114f7dd63SDavid Woodhouse u64 ino; 183214f7dd63SDavid Woodhouse loff_t offset; 183314f7dd63SDavid Woodhouse int namlen; 183414f7dd63SDavid Woodhouse unsigned int d_type; 183514f7dd63SDavid Woodhouse char name[]; 183614f7dd63SDavid Woodhouse }; 183714f7dd63SDavid Woodhouse 183814f7dd63SDavid Woodhouse struct readdir_data { 18395c0ba4e0SAl Viro struct dir_context ctx; 184014f7dd63SDavid Woodhouse char *dirent; 184114f7dd63SDavid Woodhouse size_t used; 184253c9c5c0SAl Viro int full; 184314f7dd63SDavid Woodhouse }; 184414f7dd63SDavid Woodhouse 1845ac7576f4SMiklos Szeredi static int nfsd_buffered_filldir(struct dir_context *ctx, const char *name, 1846ac7576f4SMiklos Szeredi int namlen, loff_t offset, u64 ino, 1847ac7576f4SMiklos Szeredi unsigned int d_type) 184814f7dd63SDavid Woodhouse { 1849ac7576f4SMiklos Szeredi struct readdir_data *buf = 1850ac7576f4SMiklos Szeredi container_of(ctx, struct readdir_data, ctx); 185114f7dd63SDavid Woodhouse struct buffered_dirent *de = (void *)(buf->dirent + buf->used); 185214f7dd63SDavid Woodhouse unsigned int reclen; 185314f7dd63SDavid Woodhouse 185414f7dd63SDavid Woodhouse reclen = ALIGN(sizeof(struct buffered_dirent) + namlen, sizeof(u64)); 185553c9c5c0SAl Viro if (buf->used + reclen > PAGE_SIZE) { 185653c9c5c0SAl Viro buf->full = 1; 185714f7dd63SDavid Woodhouse return -EINVAL; 185853c9c5c0SAl Viro } 185914f7dd63SDavid Woodhouse 186014f7dd63SDavid Woodhouse de->namlen = namlen; 186114f7dd63SDavid Woodhouse de->offset = offset; 186214f7dd63SDavid Woodhouse de->ino = ino; 186314f7dd63SDavid Woodhouse de->d_type = d_type; 186414f7dd63SDavid Woodhouse memcpy(de->name, name, namlen); 186514f7dd63SDavid Woodhouse buf->used += reclen; 186614f7dd63SDavid Woodhouse 186714f7dd63SDavid Woodhouse return 0; 186814f7dd63SDavid Woodhouse } 186914f7dd63SDavid Woodhouse 1870ac7576f4SMiklos Szeredi static __be32 nfsd_buffered_readdir(struct file *file, nfsd_filldir_t func, 18712628b766SDavid Woodhouse struct readdir_cd *cdp, loff_t *offsetp) 18722628b766SDavid Woodhouse { 187314f7dd63SDavid Woodhouse struct buffered_dirent *de; 18742628b766SDavid Woodhouse int host_err; 187514f7dd63SDavid Woodhouse int size; 187614f7dd63SDavid Woodhouse loff_t offset; 1877ac6614b7SAl Viro struct readdir_data buf = { 1878ac6614b7SAl Viro .ctx.actor = nfsd_buffered_filldir, 1879ac6614b7SAl Viro .dirent = (void *)__get_free_page(GFP_KERNEL) 1880ac6614b7SAl Viro }; 18812628b766SDavid Woodhouse 188214f7dd63SDavid Woodhouse if (!buf.dirent) 18832f9092e1SDavid Woodhouse return nfserrno(-ENOMEM); 188414f7dd63SDavid Woodhouse 188514f7dd63SDavid Woodhouse offset = *offsetp; 18862628b766SDavid Woodhouse 188714f7dd63SDavid Woodhouse while (1) { 1888496ad9aaSAl Viro struct inode *dir_inode = file_inode(file); 188914f7dd63SDavid Woodhouse unsigned int reclen; 189014f7dd63SDavid Woodhouse 1891b726e923SDoug Nazar cdp->err = nfserr_eof; /* will be cleared on successful read */ 189214f7dd63SDavid Woodhouse buf.used = 0; 189353c9c5c0SAl Viro buf.full = 0; 189414f7dd63SDavid Woodhouse 18955c0ba4e0SAl Viro host_err = iterate_dir(file, &buf.ctx); 189653c9c5c0SAl Viro if (buf.full) 189753c9c5c0SAl Viro host_err = 0; 189853c9c5c0SAl Viro 189953c9c5c0SAl Viro if (host_err < 0) 190014f7dd63SDavid Woodhouse break; 190114f7dd63SDavid Woodhouse 190214f7dd63SDavid Woodhouse size = buf.used; 190314f7dd63SDavid Woodhouse 190414f7dd63SDavid Woodhouse if (!size) 190514f7dd63SDavid Woodhouse break; 190614f7dd63SDavid Woodhouse 19072f9092e1SDavid Woodhouse /* 19082f9092e1SDavid Woodhouse * Various filldir functions may end up calling back into 19092f9092e1SDavid Woodhouse * lookup_one_len() and the file system's ->lookup() method. 19102f9092e1SDavid Woodhouse * These expect i_mutex to be held, as it would within readdir. 19112f9092e1SDavid Woodhouse */ 19122f9092e1SDavid Woodhouse host_err = mutex_lock_killable(&dir_inode->i_mutex); 19132f9092e1SDavid Woodhouse if (host_err) 19142f9092e1SDavid Woodhouse break; 19152f9092e1SDavid Woodhouse 191614f7dd63SDavid Woodhouse de = (struct buffered_dirent *)buf.dirent; 191714f7dd63SDavid Woodhouse while (size > 0) { 191814f7dd63SDavid Woodhouse offset = de->offset; 191914f7dd63SDavid Woodhouse 192014f7dd63SDavid Woodhouse if (func(cdp, de->name, de->namlen, de->offset, 192114f7dd63SDavid Woodhouse de->ino, de->d_type)) 19222f9092e1SDavid Woodhouse break; 192314f7dd63SDavid Woodhouse 192414f7dd63SDavid Woodhouse if (cdp->err != nfs_ok) 19252f9092e1SDavid Woodhouse break; 192614f7dd63SDavid Woodhouse 192714f7dd63SDavid Woodhouse reclen = ALIGN(sizeof(*de) + de->namlen, 192814f7dd63SDavid Woodhouse sizeof(u64)); 192914f7dd63SDavid Woodhouse size -= reclen; 193014f7dd63SDavid Woodhouse de = (struct buffered_dirent *)((char *)de + reclen); 193114f7dd63SDavid Woodhouse } 19322f9092e1SDavid Woodhouse mutex_unlock(&dir_inode->i_mutex); 19332f9092e1SDavid Woodhouse if (size > 0) /* We bailed out early */ 19342f9092e1SDavid Woodhouse break; 19352f9092e1SDavid Woodhouse 1936c002a6c7SDavid Woodhouse offset = vfs_llseek(file, 0, SEEK_CUR); 193714f7dd63SDavid Woodhouse } 193814f7dd63SDavid Woodhouse 193914f7dd63SDavid Woodhouse free_page((unsigned long)(buf.dirent)); 19402628b766SDavid Woodhouse 19412628b766SDavid Woodhouse if (host_err) 19422628b766SDavid Woodhouse return nfserrno(host_err); 194314f7dd63SDavid Woodhouse 194414f7dd63SDavid Woodhouse *offsetp = offset; 19452628b766SDavid Woodhouse return cdp->err; 19462628b766SDavid Woodhouse } 19472628b766SDavid Woodhouse 19481da177e4SLinus Torvalds /* 19491da177e4SLinus Torvalds * Read entries from a directory. 19501da177e4SLinus Torvalds * The NFSv3/4 verifier we ignore for now. 19511da177e4SLinus Torvalds */ 19526264d69dSAl Viro __be32 19531da177e4SLinus Torvalds nfsd_readdir(struct svc_rqst *rqstp, struct svc_fh *fhp, loff_t *offsetp, 1954ac7576f4SMiklos Szeredi struct readdir_cd *cdp, nfsd_filldir_t func) 19551da177e4SLinus Torvalds { 19566264d69dSAl Viro __be32 err; 19571da177e4SLinus Torvalds struct file *file; 19581da177e4SLinus Torvalds loff_t offset = *offsetp; 195906effdbbSBernd Schubert int may_flags = NFSD_MAY_READ; 19601da177e4SLinus Torvalds 196106effdbbSBernd Schubert /* NFSv2 only supports 32 bit cookies */ 196206effdbbSBernd Schubert if (rqstp->rq_vers > 2) 196306effdbbSBernd Schubert may_flags |= NFSD_MAY_64BIT_COOKIE; 196406effdbbSBernd Schubert 196506effdbbSBernd Schubert err = nfsd_open(rqstp, fhp, S_IFDIR, may_flags, &file); 19661da177e4SLinus Torvalds if (err) 19671da177e4SLinus Torvalds goto out; 19681da177e4SLinus Torvalds 1969b108fe6bSJeff Layton offset = vfs_llseek(file, offset, SEEK_SET); 19701da177e4SLinus Torvalds if (offset < 0) { 19711da177e4SLinus Torvalds err = nfserrno((int)offset); 19721da177e4SLinus Torvalds goto out_close; 19731da177e4SLinus Torvalds } 19741da177e4SLinus Torvalds 197514f7dd63SDavid Woodhouse err = nfsd_buffered_readdir(file, func, cdp, offsetp); 19761da177e4SLinus Torvalds 19771da177e4SLinus Torvalds if (err == nfserr_eof || err == nfserr_toosmall) 19781da177e4SLinus Torvalds err = nfs_ok; /* can still be found in ->err */ 19791da177e4SLinus Torvalds out_close: 19801da177e4SLinus Torvalds nfsd_close(file); 19811da177e4SLinus Torvalds out: 19821da177e4SLinus Torvalds return err; 19831da177e4SLinus Torvalds } 19841da177e4SLinus Torvalds 19851da177e4SLinus Torvalds /* 19861da177e4SLinus Torvalds * Get file system stats 19871da177e4SLinus Torvalds * N.B. After this call fhp needs an fh_put 19881da177e4SLinus Torvalds */ 19896264d69dSAl Viro __be32 199004716e66SJ. Bruce Fields nfsd_statfs(struct svc_rqst *rqstp, struct svc_fh *fhp, struct kstatfs *stat, int access) 19911da177e4SLinus Torvalds { 1992f6360efbSTakashi Iwai __be32 err; 1993f6360efbSTakashi Iwai 1994f6360efbSTakashi Iwai err = fh_verify(rqstp, fhp, 0, NFSD_MAY_NOP | access); 1995f6360efbSTakashi Iwai if (!err) { 1996ebabe9a9SChristoph Hellwig struct path path = { 1997ebabe9a9SChristoph Hellwig .mnt = fhp->fh_export->ex_path.mnt, 1998ebabe9a9SChristoph Hellwig .dentry = fhp->fh_dentry, 1999ebabe9a9SChristoph Hellwig }; 2000f6360efbSTakashi Iwai if (vfs_statfs(&path, stat)) 20011da177e4SLinus Torvalds err = nfserr_io; 2002f6360efbSTakashi Iwai } 20031da177e4SLinus Torvalds return err; 20041da177e4SLinus Torvalds } 20051da177e4SLinus Torvalds 2006c7d51402SJ. Bruce Fields static int exp_rdonly(struct svc_rqst *rqstp, struct svc_export *exp) 2007e22841c6SJ. Bruce Fields { 2008c7d51402SJ. Bruce Fields return nfsexp_flags(rqstp, exp) & NFSEXP_READONLY; 2009e22841c6SJ. Bruce Fields } 2010e22841c6SJ. Bruce Fields 20111da177e4SLinus Torvalds /* 20121da177e4SLinus Torvalds * Check for a user's access permissions to this inode. 20131da177e4SLinus Torvalds */ 20146264d69dSAl Viro __be32 20150ec757dfSJ. Bruce Fields nfsd_permission(struct svc_rqst *rqstp, struct svc_export *exp, 20160ec757dfSJ. Bruce Fields struct dentry *dentry, int acc) 20171da177e4SLinus Torvalds { 2018*2b0143b5SDavid Howells struct inode *inode = d_inode(dentry); 20191da177e4SLinus Torvalds int err; 20201da177e4SLinus Torvalds 2021aea93397SJ. Bruce Fields if ((acc & NFSD_MAY_MASK) == NFSD_MAY_NOP) 20221da177e4SLinus Torvalds return 0; 20231da177e4SLinus Torvalds #if 0 20241da177e4SLinus Torvalds dprintk("nfsd: permission 0x%x%s%s%s%s%s%s%s mode 0%o%s%s%s\n", 20251da177e4SLinus Torvalds acc, 20268837abcaSMiklos Szeredi (acc & NFSD_MAY_READ)? " read" : "", 20278837abcaSMiklos Szeredi (acc & NFSD_MAY_WRITE)? " write" : "", 20288837abcaSMiklos Szeredi (acc & NFSD_MAY_EXEC)? " exec" : "", 20298837abcaSMiklos Szeredi (acc & NFSD_MAY_SATTR)? " sattr" : "", 20308837abcaSMiklos Szeredi (acc & NFSD_MAY_TRUNC)? " trunc" : "", 20318837abcaSMiklos Szeredi (acc & NFSD_MAY_LOCK)? " lock" : "", 20328837abcaSMiklos Szeredi (acc & NFSD_MAY_OWNER_OVERRIDE)? " owneroverride" : "", 20331da177e4SLinus Torvalds inode->i_mode, 20341da177e4SLinus Torvalds IS_IMMUTABLE(inode)? " immut" : "", 20351da177e4SLinus Torvalds IS_APPEND(inode)? " append" : "", 20362c463e95SDave Hansen __mnt_is_readonly(exp->ex_path.mnt)? " ro" : ""); 20371da177e4SLinus Torvalds dprintk(" owner %d/%d user %d/%d\n", 20385cc0a840SDavid Howells inode->i_uid, inode->i_gid, current_fsuid(), current_fsgid()); 20391da177e4SLinus Torvalds #endif 20401da177e4SLinus Torvalds 20411da177e4SLinus Torvalds /* Normally we reject any write/sattr etc access on a read-only file 20421da177e4SLinus Torvalds * system. But if it is IRIX doing check on write-access for a 20431da177e4SLinus Torvalds * device special file, we ignore rofs. 20441da177e4SLinus Torvalds */ 20458837abcaSMiklos Szeredi if (!(acc & NFSD_MAY_LOCAL_ACCESS)) 20468837abcaSMiklos Szeredi if (acc & (NFSD_MAY_WRITE | NFSD_MAY_SATTR | NFSD_MAY_TRUNC)) { 20472c463e95SDave Hansen if (exp_rdonly(rqstp, exp) || 20482c463e95SDave Hansen __mnt_is_readonly(exp->ex_path.mnt)) 20491da177e4SLinus Torvalds return nfserr_rofs; 20508837abcaSMiklos Szeredi if (/* (acc & NFSD_MAY_WRITE) && */ IS_IMMUTABLE(inode)) 20511da177e4SLinus Torvalds return nfserr_perm; 20521da177e4SLinus Torvalds } 20538837abcaSMiklos Szeredi if ((acc & NFSD_MAY_TRUNC) && IS_APPEND(inode)) 20541da177e4SLinus Torvalds return nfserr_perm; 20551da177e4SLinus Torvalds 20568837abcaSMiklos Szeredi if (acc & NFSD_MAY_LOCK) { 20571da177e4SLinus Torvalds /* If we cannot rely on authentication in NLM requests, 20581da177e4SLinus Torvalds * just allow locks, otherwise require read permission, or 20591da177e4SLinus Torvalds * ownership 20601da177e4SLinus Torvalds */ 20611da177e4SLinus Torvalds if (exp->ex_flags & NFSEXP_NOAUTHNLM) 20621da177e4SLinus Torvalds return 0; 20631da177e4SLinus Torvalds else 20648837abcaSMiklos Szeredi acc = NFSD_MAY_READ | NFSD_MAY_OWNER_OVERRIDE; 20651da177e4SLinus Torvalds } 20661da177e4SLinus Torvalds /* 20671da177e4SLinus Torvalds * The file owner always gets access permission for accesses that 20681da177e4SLinus Torvalds * would normally be checked at open time. This is to make 20691da177e4SLinus Torvalds * file access work even when the client has done a fchmod(fd, 0). 20701da177e4SLinus Torvalds * 20711da177e4SLinus Torvalds * However, `cp foo bar' should fail nevertheless when bar is 20721da177e4SLinus Torvalds * readonly. A sensible way to do this might be to reject all 20731da177e4SLinus Torvalds * attempts to truncate a read-only file, because a creat() call 20741da177e4SLinus Torvalds * always implies file truncation. 20751da177e4SLinus Torvalds * ... but this isn't really fair. A process may reasonably call 20761da177e4SLinus Torvalds * ftruncate on an open file descriptor on a file with perm 000. 20771da177e4SLinus Torvalds * We must trust the client to do permission checking - using "ACCESS" 20781da177e4SLinus Torvalds * with NFSv3. 20791da177e4SLinus Torvalds */ 20808837abcaSMiklos Szeredi if ((acc & NFSD_MAY_OWNER_OVERRIDE) && 20816fab8779SEric W. Biederman uid_eq(inode->i_uid, current_fsuid())) 20821da177e4SLinus Torvalds return 0; 20831da177e4SLinus Torvalds 20848837abcaSMiklos Szeredi /* This assumes NFSD_MAY_{READ,WRITE,EXEC} == MAY_{READ,WRITE,EXEC} */ 2085f419a2e3SAl Viro err = inode_permission(inode, acc & (MAY_READ|MAY_WRITE|MAY_EXEC)); 20861da177e4SLinus Torvalds 20871da177e4SLinus Torvalds /* Allow read access to binaries even when mode 111 */ 20881da177e4SLinus Torvalds if (err == -EACCES && S_ISREG(inode->i_mode) && 2089a043226bSJ. Bruce Fields (acc == (NFSD_MAY_READ | NFSD_MAY_OWNER_OVERRIDE) || 2090a043226bSJ. Bruce Fields acc == (NFSD_MAY_READ | NFSD_MAY_READ_IF_EXEC))) 2091f419a2e3SAl Viro err = inode_permission(inode, MAY_EXEC); 20921da177e4SLinus Torvalds 20931da177e4SLinus Torvalds return err? nfserrno(err) : 0; 20941da177e4SLinus Torvalds } 20951da177e4SLinus Torvalds 20961da177e4SLinus Torvalds void 20971da177e4SLinus Torvalds nfsd_racache_shutdown(void) 20981da177e4SLinus Torvalds { 209954a66e54SJeff Layton struct raparms *raparm, *last_raparm; 210054a66e54SJeff Layton unsigned int i; 210154a66e54SJeff Layton 21021da177e4SLinus Torvalds dprintk("nfsd: freeing readahead buffers.\n"); 210354a66e54SJeff Layton 210454a66e54SJeff Layton for (i = 0; i < RAPARM_HASH_SIZE; i++) { 210554a66e54SJeff Layton raparm = raparm_hash[i].pb_head; 210654a66e54SJeff Layton while(raparm) { 210754a66e54SJeff Layton last_raparm = raparm; 210854a66e54SJeff Layton raparm = raparm->p_next; 210954a66e54SJeff Layton kfree(last_raparm); 211054a66e54SJeff Layton } 211154a66e54SJeff Layton raparm_hash[i].pb_head = NULL; 211254a66e54SJeff Layton } 21131da177e4SLinus Torvalds } 21141da177e4SLinus Torvalds /* 21151da177e4SLinus Torvalds * Initialize readahead param cache 21161da177e4SLinus Torvalds */ 21171da177e4SLinus Torvalds int 21181da177e4SLinus Torvalds nfsd_racache_init(int cache_size) 21191da177e4SLinus Torvalds { 21201da177e4SLinus Torvalds int i; 2121fce1456aSGreg Banks int j = 0; 2122fce1456aSGreg Banks int nperbucket; 212354a66e54SJeff Layton struct raparms **raparm = NULL; 21241da177e4SLinus Torvalds 2125fce1456aSGreg Banks 212654a66e54SJeff Layton if (raparm_hash[0].pb_head) 21271da177e4SLinus Torvalds return 0; 212854a66e54SJeff Layton nperbucket = DIV_ROUND_UP(cache_size, RAPARM_HASH_SIZE); 21293c7aa15dSKinglong Mee nperbucket = max(2, nperbucket); 213054a66e54SJeff Layton cache_size = nperbucket * RAPARM_HASH_SIZE; 21314b3bb06bSYan Burman 21324b3bb06bSYan Burman dprintk("nfsd: allocating %d readahead buffers.\n", cache_size); 213354a66e54SJeff Layton 2134fce1456aSGreg Banks for (i = 0; i < RAPARM_HASH_SIZE; i++) { 2135fce1456aSGreg Banks spin_lock_init(&raparm_hash[i].pb_lock); 213654a66e54SJeff Layton 213754a66e54SJeff Layton raparm = &raparm_hash[i].pb_head; 213854a66e54SJeff Layton for (j = 0; j < nperbucket; j++) { 213954a66e54SJeff Layton *raparm = kzalloc(sizeof(struct raparms), GFP_KERNEL); 214054a66e54SJeff Layton if (!*raparm) 214154a66e54SJeff Layton goto out_nomem; 214254a66e54SJeff Layton raparm = &(*raparm)->p_next; 2143fce1456aSGreg Banks } 214454a66e54SJeff Layton *raparm = NULL; 21451da177e4SLinus Torvalds } 21464b3bb06bSYan Burman 21471da177e4SLinus Torvalds nfsdstats.ra_size = cache_size; 21481da177e4SLinus Torvalds return 0; 214954a66e54SJeff Layton 215054a66e54SJeff Layton out_nomem: 215154a66e54SJeff Layton dprintk("nfsd: kmalloc failed, freeing readahead buffers\n"); 215254a66e54SJeff Layton nfsd_racache_shutdown(); 215354a66e54SJeff Layton return -ENOMEM; 21541da177e4SLinus Torvalds } 2155