xref: /openbmc/linux/fs/nfsd/vfs.c (revision 545e4006)
1 #define MSNFS	/* HACK HACK */
2 /*
3  * linux/fs/nfsd/vfs.c
4  *
5  * File operations used by nfsd. Some of these have been ripped from
6  * other parts of the kernel because they weren't exported, others
7  * are partial duplicates with added or changed functionality.
8  *
9  * Note that several functions dget() the dentry upon which they want
10  * to act, most notably those that create directory entries. Response
11  * dentry's are dput()'d if necessary in the release callback.
12  * So if you notice code paths that apparently fail to dput() the
13  * dentry, don't worry--they have been taken care of.
14  *
15  * Copyright (C) 1995-1999 Olaf Kirch <okir@monad.swb.de>
16  * Zerocpy NFS support (C) 2002 Hirokazu Takahashi <taka@valinux.co.jp>
17  */
18 
19 #include <linux/string.h>
20 #include <linux/time.h>
21 #include <linux/errno.h>
22 #include <linux/fs.h>
23 #include <linux/file.h>
24 #include <linux/mount.h>
25 #include <linux/major.h>
26 #include <linux/splice.h>
27 #include <linux/proc_fs.h>
28 #include <linux/stat.h>
29 #include <linux/fcntl.h>
30 #include <linux/net.h>
31 #include <linux/unistd.h>
32 #include <linux/slab.h>
33 #include <linux/pagemap.h>
34 #include <linux/in.h>
35 #include <linux/module.h>
36 #include <linux/namei.h>
37 #include <linux/vfs.h>
38 #include <linux/delay.h>
39 #include <linux/sunrpc/svc.h>
40 #include <linux/nfsd/nfsd.h>
41 #ifdef CONFIG_NFSD_V3
42 #include <linux/nfs3.h>
43 #include <linux/nfsd/xdr3.h>
44 #endif /* CONFIG_NFSD_V3 */
45 #include <linux/nfsd/nfsfh.h>
46 #include <linux/quotaops.h>
47 #include <linux/fsnotify.h>
48 #include <linux/posix_acl.h>
49 #include <linux/posix_acl_xattr.h>
50 #include <linux/xattr.h>
51 #ifdef CONFIG_NFSD_V4
52 #include <linux/nfs4.h>
53 #include <linux/nfs4_acl.h>
54 #include <linux/nfsd_idmap.h>
55 #include <linux/security.h>
56 #endif /* CONFIG_NFSD_V4 */
57 #include <linux/jhash.h>
58 
59 #include <asm/uaccess.h>
60 
61 #define NFSDDBG_FACILITY		NFSDDBG_FILEOP
62 
63 
64 /*
65  * This is a cache of readahead params that help us choose the proper
66  * readahead strategy. Initially, we set all readahead parameters to 0
67  * and let the VFS handle things.
68  * If you increase the number of cached files very much, you'll need to
69  * add a hash table here.
70  */
71 struct raparms {
72 	struct raparms		*p_next;
73 	unsigned int		p_count;
74 	ino_t			p_ino;
75 	dev_t			p_dev;
76 	int			p_set;
77 	struct file_ra_state	p_ra;
78 	unsigned int		p_hindex;
79 };
80 
81 struct raparm_hbucket {
82 	struct raparms		*pb_head;
83 	spinlock_t		pb_lock;
84 } ____cacheline_aligned_in_smp;
85 
86 static struct raparms *		raparml;
87 #define RAPARM_HASH_BITS	4
88 #define RAPARM_HASH_SIZE	(1<<RAPARM_HASH_BITS)
89 #define RAPARM_HASH_MASK	(RAPARM_HASH_SIZE-1)
90 static struct raparm_hbucket	raparm_hash[RAPARM_HASH_SIZE];
91 
92 /*
93  * Called from nfsd_lookup and encode_dirent. Check if we have crossed
94  * a mount point.
95  * Returns -EAGAIN or -ETIMEDOUT leaving *dpp and *expp unchanged,
96  *  or nfs_ok having possibly changed *dpp and *expp
97  */
98 int
99 nfsd_cross_mnt(struct svc_rqst *rqstp, struct dentry **dpp,
100 		        struct svc_export **expp)
101 {
102 	struct svc_export *exp = *expp, *exp2 = NULL;
103 	struct dentry *dentry = *dpp;
104 	struct vfsmount *mnt = mntget(exp->ex_path.mnt);
105 	struct dentry *mounts = dget(dentry);
106 	int err = 0;
107 
108 	while (follow_down(&mnt,&mounts)&&d_mountpoint(mounts));
109 
110 	exp2 = rqst_exp_get_by_name(rqstp, mnt, mounts);
111 	if (IS_ERR(exp2)) {
112 		if (PTR_ERR(exp2) != -ENOENT)
113 			err = PTR_ERR(exp2);
114 		dput(mounts);
115 		mntput(mnt);
116 		goto out;
117 	}
118 	if ((exp->ex_flags & NFSEXP_CROSSMOUNT) || EX_NOHIDE(exp2)) {
119 		/* successfully crossed mount point */
120 		exp_put(exp);
121 		*expp = exp2;
122 		dput(dentry);
123 		*dpp = mounts;
124 	} else {
125 		exp_put(exp2);
126 		dput(mounts);
127 	}
128 	mntput(mnt);
129 out:
130 	return err;
131 }
132 
133 __be32
134 nfsd_lookup_dentry(struct svc_rqst *rqstp, struct svc_fh *fhp,
135 		   const char *name, unsigned int len,
136 		   struct svc_export **exp_ret, struct dentry **dentry_ret)
137 {
138 	struct svc_export	*exp;
139 	struct dentry		*dparent;
140 	struct dentry		*dentry;
141 	__be32			err;
142 	int			host_err;
143 
144 	dprintk("nfsd: nfsd_lookup(fh %s, %.*s)\n", SVCFH_fmt(fhp), len,name);
145 
146 	/* Obtain dentry and export. */
147 	err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_EXEC);
148 	if (err)
149 		return err;
150 
151 	dparent = fhp->fh_dentry;
152 	exp  = fhp->fh_export;
153 	exp_get(exp);
154 
155 	/* Lookup the name, but don't follow links */
156 	if (isdotent(name, len)) {
157 		if (len==1)
158 			dentry = dget(dparent);
159 		else if (dparent != exp->ex_path.dentry)
160 			dentry = dget_parent(dparent);
161 		else if (!EX_NOHIDE(exp))
162 			dentry = dget(dparent); /* .. == . just like at / */
163 		else {
164 			/* checking mountpoint crossing is very different when stepping up */
165 			struct svc_export *exp2 = NULL;
166 			struct dentry *dp;
167 			struct vfsmount *mnt = mntget(exp->ex_path.mnt);
168 			dentry = dget(dparent);
169 			while(dentry == mnt->mnt_root && follow_up(&mnt, &dentry))
170 				;
171 			dp = dget_parent(dentry);
172 			dput(dentry);
173 			dentry = dp;
174 
175 			exp2 = rqst_exp_parent(rqstp, mnt, dentry);
176 			if (PTR_ERR(exp2) == -ENOENT) {
177 				dput(dentry);
178 				dentry = dget(dparent);
179 			} else if (IS_ERR(exp2)) {
180 				host_err = PTR_ERR(exp2);
181 				dput(dentry);
182 				mntput(mnt);
183 				goto out_nfserr;
184 			} else {
185 				exp_put(exp);
186 				exp = exp2;
187 			}
188 			mntput(mnt);
189 		}
190 	} else {
191 		fh_lock(fhp);
192 		dentry = lookup_one_len(name, dparent, len);
193 		host_err = PTR_ERR(dentry);
194 		if (IS_ERR(dentry))
195 			goto out_nfserr;
196 		/*
197 		 * check if we have crossed a mount point ...
198 		 */
199 		if (d_mountpoint(dentry)) {
200 			if ((host_err = nfsd_cross_mnt(rqstp, &dentry, &exp))) {
201 				dput(dentry);
202 				goto out_nfserr;
203 			}
204 		}
205 	}
206 	*dentry_ret = dentry;
207 	*exp_ret = exp;
208 	return 0;
209 
210 out_nfserr:
211 	exp_put(exp);
212 	return nfserrno(host_err);
213 }
214 
215 /*
216  * Look up one component of a pathname.
217  * N.B. After this call _both_ fhp and resfh need an fh_put
218  *
219  * If the lookup would cross a mountpoint, and the mounted filesystem
220  * is exported to the client with NFSEXP_NOHIDE, then the lookup is
221  * accepted as it stands and the mounted directory is
222  * returned. Otherwise the covered directory is returned.
223  * NOTE: this mountpoint crossing is not supported properly by all
224  *   clients and is explicitly disallowed for NFSv3
225  *      NeilBrown <neilb@cse.unsw.edu.au>
226  */
227 __be32
228 nfsd_lookup(struct svc_rqst *rqstp, struct svc_fh *fhp, const char *name,
229 				unsigned int len, struct svc_fh *resfh)
230 {
231 	struct svc_export	*exp;
232 	struct dentry		*dentry;
233 	__be32 err;
234 
235 	err = nfsd_lookup_dentry(rqstp, fhp, name, len, &exp, &dentry);
236 	if (err)
237 		return err;
238 	err = check_nfsd_access(exp, rqstp);
239 	if (err)
240 		goto out;
241 	/*
242 	 * Note: we compose the file handle now, but as the
243 	 * dentry may be negative, it may need to be updated.
244 	 */
245 	err = fh_compose(resfh, exp, dentry, fhp);
246 	if (!err && !dentry->d_inode)
247 		err = nfserr_noent;
248 out:
249 	dput(dentry);
250 	exp_put(exp);
251 	return err;
252 }
253 
254 
255 /*
256  * Set various file attributes.
257  * N.B. After this call fhp needs an fh_put
258  */
259 __be32
260 nfsd_setattr(struct svc_rqst *rqstp, struct svc_fh *fhp, struct iattr *iap,
261 	     int check_guard, time_t guardtime)
262 {
263 	struct dentry	*dentry;
264 	struct inode	*inode;
265 	int		accmode = NFSD_MAY_SATTR;
266 	int		ftype = 0;
267 	__be32		err;
268 	int		host_err;
269 	int		size_change = 0;
270 
271 	if (iap->ia_valid & (ATTR_ATIME | ATTR_MTIME | ATTR_SIZE))
272 		accmode |= NFSD_MAY_WRITE|NFSD_MAY_OWNER_OVERRIDE;
273 	if (iap->ia_valid & ATTR_SIZE)
274 		ftype = S_IFREG;
275 
276 	/* Get inode */
277 	err = fh_verify(rqstp, fhp, ftype, accmode);
278 	if (err)
279 		goto out;
280 
281 	dentry = fhp->fh_dentry;
282 	inode = dentry->d_inode;
283 
284 	/* Ignore any mode updates on symlinks */
285 	if (S_ISLNK(inode->i_mode))
286 		iap->ia_valid &= ~ATTR_MODE;
287 
288 	if (!iap->ia_valid)
289 		goto out;
290 
291 	/*
292 	 * NFSv2 does not differentiate between "set-[ac]time-to-now"
293 	 * which only requires access, and "set-[ac]time-to-X" which
294 	 * requires ownership.
295 	 * So if it looks like it might be "set both to the same time which
296 	 * is close to now", and if inode_change_ok fails, then we
297 	 * convert to "set to now" instead of "set to explicit time"
298 	 *
299 	 * We only call inode_change_ok as the last test as technically
300 	 * it is not an interface that we should be using.  It is only
301 	 * valid if the filesystem does not define it's own i_op->setattr.
302 	 */
303 #define BOTH_TIME_SET (ATTR_ATIME_SET | ATTR_MTIME_SET)
304 #define	MAX_TOUCH_TIME_ERROR (30*60)
305 	if ((iap->ia_valid & BOTH_TIME_SET) == BOTH_TIME_SET &&
306 	    iap->ia_mtime.tv_sec == iap->ia_atime.tv_sec) {
307 		/*
308 		 * Looks probable.
309 		 *
310 		 * Now just make sure time is in the right ballpark.
311 		 * Solaris, at least, doesn't seem to care what the time
312 		 * request is.  We require it be within 30 minutes of now.
313 		 */
314 		time_t delta = iap->ia_atime.tv_sec - get_seconds();
315 		if (delta < 0)
316 			delta = -delta;
317 		if (delta < MAX_TOUCH_TIME_ERROR &&
318 		    inode_change_ok(inode, iap) != 0) {
319 			/*
320 			 * Turn off ATTR_[AM]TIME_SET but leave ATTR_[AM]TIME.
321 			 * This will cause notify_change to set these times
322 			 * to "now"
323 			 */
324 			iap->ia_valid &= ~BOTH_TIME_SET;
325 		}
326 	}
327 
328 	/*
329 	 * The size case is special.
330 	 * It changes the file as well as the attributes.
331 	 */
332 	if (iap->ia_valid & ATTR_SIZE) {
333 		if (iap->ia_size < inode->i_size) {
334 			err = nfsd_permission(rqstp, fhp->fh_export, dentry,
335 					NFSD_MAY_TRUNC|NFSD_MAY_OWNER_OVERRIDE);
336 			if (err)
337 				goto out;
338 		}
339 
340 		/*
341 		 * If we are changing the size of the file, then
342 		 * we need to break all leases.
343 		 */
344 		host_err = break_lease(inode, FMODE_WRITE | O_NONBLOCK);
345 		if (host_err == -EWOULDBLOCK)
346 			host_err = -ETIMEDOUT;
347 		if (host_err) /* ENOMEM or EWOULDBLOCK */
348 			goto out_nfserr;
349 
350 		host_err = get_write_access(inode);
351 		if (host_err)
352 			goto out_nfserr;
353 
354 		size_change = 1;
355 		host_err = locks_verify_truncate(inode, NULL, iap->ia_size);
356 		if (host_err) {
357 			put_write_access(inode);
358 			goto out_nfserr;
359 		}
360 		DQUOT_INIT(inode);
361 	}
362 
363 	/* sanitize the mode change */
364 	if (iap->ia_valid & ATTR_MODE) {
365 		iap->ia_mode &= S_IALLUGO;
366 		iap->ia_mode |= (inode->i_mode & ~S_IALLUGO);
367 	}
368 
369 	/* Revoke setuid/setgid on chown */
370 	if (((iap->ia_valid & ATTR_UID) && iap->ia_uid != inode->i_uid) ||
371 	    ((iap->ia_valid & ATTR_GID) && iap->ia_gid != inode->i_gid)) {
372 		iap->ia_valid |= ATTR_KILL_PRIV;
373 		if (iap->ia_valid & ATTR_MODE) {
374 			/* we're setting mode too, just clear the s*id bits */
375 			iap->ia_mode &= ~S_ISUID;
376 			if (iap->ia_mode & S_IXGRP)
377 				iap->ia_mode &= ~S_ISGID;
378 		} else {
379 			/* set ATTR_KILL_* bits and let VFS handle it */
380 			iap->ia_valid |= (ATTR_KILL_SUID | ATTR_KILL_SGID);
381 		}
382 	}
383 
384 	/* Change the attributes. */
385 
386 	iap->ia_valid |= ATTR_CTIME;
387 
388 	err = nfserr_notsync;
389 	if (!check_guard || guardtime == inode->i_ctime.tv_sec) {
390 		fh_lock(fhp);
391 		host_err = notify_change(dentry, iap);
392 		err = nfserrno(host_err);
393 		fh_unlock(fhp);
394 	}
395 	if (size_change)
396 		put_write_access(inode);
397 	if (!err)
398 		if (EX_ISSYNC(fhp->fh_export))
399 			write_inode_now(inode, 1);
400 out:
401 	return err;
402 
403 out_nfserr:
404 	err = nfserrno(host_err);
405 	goto out;
406 }
407 
408 #if defined(CONFIG_NFSD_V2_ACL) || \
409     defined(CONFIG_NFSD_V3_ACL) || \
410     defined(CONFIG_NFSD_V4)
411 static ssize_t nfsd_getxattr(struct dentry *dentry, char *key, void **buf)
412 {
413 	ssize_t buflen;
414 
415 	buflen = vfs_getxattr(dentry, key, NULL, 0);
416 	if (buflen <= 0)
417 		return buflen;
418 
419 	*buf = kmalloc(buflen, GFP_KERNEL);
420 	if (!*buf)
421 		return -ENOMEM;
422 
423 	return vfs_getxattr(dentry, key, *buf, buflen);
424 }
425 #endif
426 
427 #if defined(CONFIG_NFSD_V4)
428 static int
429 set_nfsv4_acl_one(struct dentry *dentry, struct posix_acl *pacl, char *key)
430 {
431 	int len;
432 	size_t buflen;
433 	char *buf = NULL;
434 	int error = 0;
435 
436 	buflen = posix_acl_xattr_size(pacl->a_count);
437 	buf = kmalloc(buflen, GFP_KERNEL);
438 	error = -ENOMEM;
439 	if (buf == NULL)
440 		goto out;
441 
442 	len = posix_acl_to_xattr(pacl, buf, buflen);
443 	if (len < 0) {
444 		error = len;
445 		goto out;
446 	}
447 
448 	error = vfs_setxattr(dentry, key, buf, len, 0);
449 out:
450 	kfree(buf);
451 	return error;
452 }
453 
454 __be32
455 nfsd4_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp,
456     struct nfs4_acl *acl)
457 {
458 	__be32 error;
459 	int host_error;
460 	struct dentry *dentry;
461 	struct inode *inode;
462 	struct posix_acl *pacl = NULL, *dpacl = NULL;
463 	unsigned int flags = 0;
464 
465 	/* Get inode */
466 	error = fh_verify(rqstp, fhp, 0 /* S_IFREG */, NFSD_MAY_SATTR);
467 	if (error)
468 		return error;
469 
470 	dentry = fhp->fh_dentry;
471 	inode = dentry->d_inode;
472 	if (S_ISDIR(inode->i_mode))
473 		flags = NFS4_ACL_DIR;
474 
475 	host_error = nfs4_acl_nfsv4_to_posix(acl, &pacl, &dpacl, flags);
476 	if (host_error == -EINVAL) {
477 		return nfserr_attrnotsupp;
478 	} else if (host_error < 0)
479 		goto out_nfserr;
480 
481 	host_error = set_nfsv4_acl_one(dentry, pacl, POSIX_ACL_XATTR_ACCESS);
482 	if (host_error < 0)
483 		goto out_release;
484 
485 	if (S_ISDIR(inode->i_mode))
486 		host_error = set_nfsv4_acl_one(dentry, dpacl, POSIX_ACL_XATTR_DEFAULT);
487 
488 out_release:
489 	posix_acl_release(pacl);
490 	posix_acl_release(dpacl);
491 out_nfserr:
492 	if (host_error == -EOPNOTSUPP)
493 		return nfserr_attrnotsupp;
494 	else
495 		return nfserrno(host_error);
496 }
497 
498 static struct posix_acl *
499 _get_posix_acl(struct dentry *dentry, char *key)
500 {
501 	void *buf = NULL;
502 	struct posix_acl *pacl = NULL;
503 	int buflen;
504 
505 	buflen = nfsd_getxattr(dentry, key, &buf);
506 	if (!buflen)
507 		buflen = -ENODATA;
508 	if (buflen <= 0)
509 		return ERR_PTR(buflen);
510 
511 	pacl = posix_acl_from_xattr(buf, buflen);
512 	kfree(buf);
513 	return pacl;
514 }
515 
516 int
517 nfsd4_get_nfs4_acl(struct svc_rqst *rqstp, struct dentry *dentry, struct nfs4_acl **acl)
518 {
519 	struct inode *inode = dentry->d_inode;
520 	int error = 0;
521 	struct posix_acl *pacl = NULL, *dpacl = NULL;
522 	unsigned int flags = 0;
523 
524 	pacl = _get_posix_acl(dentry, POSIX_ACL_XATTR_ACCESS);
525 	if (IS_ERR(pacl) && PTR_ERR(pacl) == -ENODATA)
526 		pacl = posix_acl_from_mode(inode->i_mode, GFP_KERNEL);
527 	if (IS_ERR(pacl)) {
528 		error = PTR_ERR(pacl);
529 		pacl = NULL;
530 		goto out;
531 	}
532 
533 	if (S_ISDIR(inode->i_mode)) {
534 		dpacl = _get_posix_acl(dentry, POSIX_ACL_XATTR_DEFAULT);
535 		if (IS_ERR(dpacl) && PTR_ERR(dpacl) == -ENODATA)
536 			dpacl = NULL;
537 		else if (IS_ERR(dpacl)) {
538 			error = PTR_ERR(dpacl);
539 			dpacl = NULL;
540 			goto out;
541 		}
542 		flags = NFS4_ACL_DIR;
543 	}
544 
545 	*acl = nfs4_acl_posix_to_nfsv4(pacl, dpacl, flags);
546 	if (IS_ERR(*acl)) {
547 		error = PTR_ERR(*acl);
548 		*acl = NULL;
549 	}
550  out:
551 	posix_acl_release(pacl);
552 	posix_acl_release(dpacl);
553 	return error;
554 }
555 
556 #endif /* defined(CONFIG_NFS_V4) */
557 
558 #ifdef CONFIG_NFSD_V3
559 /*
560  * Check server access rights to a file system object
561  */
562 struct accessmap {
563 	u32		access;
564 	int		how;
565 };
566 static struct accessmap	nfs3_regaccess[] = {
567     {	NFS3_ACCESS_READ,	NFSD_MAY_READ			},
568     {	NFS3_ACCESS_EXECUTE,	NFSD_MAY_EXEC			},
569     {	NFS3_ACCESS_MODIFY,	NFSD_MAY_WRITE|NFSD_MAY_TRUNC	},
570     {	NFS3_ACCESS_EXTEND,	NFSD_MAY_WRITE			},
571 
572     {	0,			0				}
573 };
574 
575 static struct accessmap	nfs3_diraccess[] = {
576     {	NFS3_ACCESS_READ,	NFSD_MAY_READ			},
577     {	NFS3_ACCESS_LOOKUP,	NFSD_MAY_EXEC			},
578     {	NFS3_ACCESS_MODIFY,	NFSD_MAY_EXEC|NFSD_MAY_WRITE|NFSD_MAY_TRUNC},
579     {	NFS3_ACCESS_EXTEND,	NFSD_MAY_EXEC|NFSD_MAY_WRITE	},
580     {	NFS3_ACCESS_DELETE,	NFSD_MAY_REMOVE			},
581 
582     {	0,			0				}
583 };
584 
585 static struct accessmap	nfs3_anyaccess[] = {
586 	/* Some clients - Solaris 2.6 at least, make an access call
587 	 * to the server to check for access for things like /dev/null
588 	 * (which really, the server doesn't care about).  So
589 	 * We provide simple access checking for them, looking
590 	 * mainly at mode bits, and we make sure to ignore read-only
591 	 * filesystem checks
592 	 */
593     {	NFS3_ACCESS_READ,	NFSD_MAY_READ			},
594     {	NFS3_ACCESS_EXECUTE,	NFSD_MAY_EXEC			},
595     {	NFS3_ACCESS_MODIFY,	NFSD_MAY_WRITE|NFSD_MAY_LOCAL_ACCESS	},
596     {	NFS3_ACCESS_EXTEND,	NFSD_MAY_WRITE|NFSD_MAY_LOCAL_ACCESS	},
597 
598     {	0,			0				}
599 };
600 
601 __be32
602 nfsd_access(struct svc_rqst *rqstp, struct svc_fh *fhp, u32 *access, u32 *supported)
603 {
604 	struct accessmap	*map;
605 	struct svc_export	*export;
606 	struct dentry		*dentry;
607 	u32			query, result = 0, sresult = 0;
608 	__be32			error;
609 
610 	error = fh_verify(rqstp, fhp, 0, NFSD_MAY_NOP);
611 	if (error)
612 		goto out;
613 
614 	export = fhp->fh_export;
615 	dentry = fhp->fh_dentry;
616 
617 	if (S_ISREG(dentry->d_inode->i_mode))
618 		map = nfs3_regaccess;
619 	else if (S_ISDIR(dentry->d_inode->i_mode))
620 		map = nfs3_diraccess;
621 	else
622 		map = nfs3_anyaccess;
623 
624 
625 	query = *access;
626 	for  (; map->access; map++) {
627 		if (map->access & query) {
628 			__be32 err2;
629 
630 			sresult |= map->access;
631 
632 			err2 = nfsd_permission(rqstp, export, dentry, map->how);
633 			switch (err2) {
634 			case nfs_ok:
635 				result |= map->access;
636 				break;
637 
638 			/* the following error codes just mean the access was not allowed,
639 			 * rather than an error occurred */
640 			case nfserr_rofs:
641 			case nfserr_acces:
642 			case nfserr_perm:
643 				/* simply don't "or" in the access bit. */
644 				break;
645 			default:
646 				error = err2;
647 				goto out;
648 			}
649 		}
650 	}
651 	*access = result;
652 	if (supported)
653 		*supported = sresult;
654 
655  out:
656 	return error;
657 }
658 #endif /* CONFIG_NFSD_V3 */
659 
660 
661 
662 /*
663  * Open an existing file or directory.
664  * The access argument indicates the type of open (read/write/lock)
665  * N.B. After this call fhp needs an fh_put
666  */
667 __be32
668 nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
669 			int access, struct file **filp)
670 {
671 	struct dentry	*dentry;
672 	struct inode	*inode;
673 	int		flags = O_RDONLY|O_LARGEFILE;
674 	__be32		err;
675 	int		host_err;
676 
677 	/*
678 	 * If we get here, then the client has already done an "open",
679 	 * and (hopefully) checked permission - so allow OWNER_OVERRIDE
680 	 * in case a chmod has now revoked permission.
681 	 */
682 	err = fh_verify(rqstp, fhp, type, access | NFSD_MAY_OWNER_OVERRIDE);
683 	if (err)
684 		goto out;
685 
686 	dentry = fhp->fh_dentry;
687 	inode = dentry->d_inode;
688 
689 	/* Disallow write access to files with the append-only bit set
690 	 * or any access when mandatory locking enabled
691 	 */
692 	err = nfserr_perm;
693 	if (IS_APPEND(inode) && (access & NFSD_MAY_WRITE))
694 		goto out;
695 	/*
696 	 * We must ignore files (but only files) which might have mandatory
697 	 * locks on them because there is no way to know if the accesser has
698 	 * the lock.
699 	 */
700 	if (S_ISREG((inode)->i_mode) && mandatory_lock(inode))
701 		goto out;
702 
703 	if (!inode->i_fop)
704 		goto out;
705 
706 	/*
707 	 * Check to see if there are any leases on this file.
708 	 * This may block while leases are broken.
709 	 */
710 	host_err = break_lease(inode, O_NONBLOCK | ((access & NFSD_MAY_WRITE) ? FMODE_WRITE : 0));
711 	if (host_err == -EWOULDBLOCK)
712 		host_err = -ETIMEDOUT;
713 	if (host_err) /* NOMEM or WOULDBLOCK */
714 		goto out_nfserr;
715 
716 	if (access & NFSD_MAY_WRITE) {
717 		if (access & NFSD_MAY_READ)
718 			flags = O_RDWR|O_LARGEFILE;
719 		else
720 			flags = O_WRONLY|O_LARGEFILE;
721 
722 		DQUOT_INIT(inode);
723 	}
724 	*filp = dentry_open(dget(dentry), mntget(fhp->fh_export->ex_path.mnt),
725 				flags);
726 	if (IS_ERR(*filp))
727 		host_err = PTR_ERR(*filp);
728 out_nfserr:
729 	err = nfserrno(host_err);
730 out:
731 	return err;
732 }
733 
734 /*
735  * Close a file.
736  */
737 void
738 nfsd_close(struct file *filp)
739 {
740 	fput(filp);
741 }
742 
743 /*
744  * Sync a file
745  * As this calls fsync (not fdatasync) there is no need for a write_inode
746  * after it.
747  */
748 static inline int nfsd_dosync(struct file *filp, struct dentry *dp,
749 			      const struct file_operations *fop)
750 {
751 	struct inode *inode = dp->d_inode;
752 	int (*fsync) (struct file *, struct dentry *, int);
753 	int err;
754 
755 	err = filemap_fdatawrite(inode->i_mapping);
756 	if (err == 0 && fop && (fsync = fop->fsync))
757 		err = fsync(filp, dp, 0);
758 	if (err == 0)
759 		err = filemap_fdatawait(inode->i_mapping);
760 
761 	return err;
762 }
763 
764 
765 static int
766 nfsd_sync(struct file *filp)
767 {
768         int err;
769 	struct inode *inode = filp->f_path.dentry->d_inode;
770 	dprintk("nfsd: sync file %s\n", filp->f_path.dentry->d_name.name);
771 	mutex_lock(&inode->i_mutex);
772 	err=nfsd_dosync(filp, filp->f_path.dentry, filp->f_op);
773 	mutex_unlock(&inode->i_mutex);
774 
775 	return err;
776 }
777 
778 int
779 nfsd_sync_dir(struct dentry *dp)
780 {
781 	return nfsd_dosync(NULL, dp, dp->d_inode->i_fop);
782 }
783 
784 /*
785  * Obtain the readahead parameters for the file
786  * specified by (dev, ino).
787  */
788 
789 static inline struct raparms *
790 nfsd_get_raparms(dev_t dev, ino_t ino)
791 {
792 	struct raparms	*ra, **rap, **frap = NULL;
793 	int depth = 0;
794 	unsigned int hash;
795 	struct raparm_hbucket *rab;
796 
797 	hash = jhash_2words(dev, ino, 0xfeedbeef) & RAPARM_HASH_MASK;
798 	rab = &raparm_hash[hash];
799 
800 	spin_lock(&rab->pb_lock);
801 	for (rap = &rab->pb_head; (ra = *rap); rap = &ra->p_next) {
802 		if (ra->p_ino == ino && ra->p_dev == dev)
803 			goto found;
804 		depth++;
805 		if (ra->p_count == 0)
806 			frap = rap;
807 	}
808 	depth = nfsdstats.ra_size*11/10;
809 	if (!frap) {
810 		spin_unlock(&rab->pb_lock);
811 		return NULL;
812 	}
813 	rap = frap;
814 	ra = *frap;
815 	ra->p_dev = dev;
816 	ra->p_ino = ino;
817 	ra->p_set = 0;
818 	ra->p_hindex = hash;
819 found:
820 	if (rap != &rab->pb_head) {
821 		*rap = ra->p_next;
822 		ra->p_next   = rab->pb_head;
823 		rab->pb_head = ra;
824 	}
825 	ra->p_count++;
826 	nfsdstats.ra_depth[depth*10/nfsdstats.ra_size]++;
827 	spin_unlock(&rab->pb_lock);
828 	return ra;
829 }
830 
831 /*
832  * Grab and keep cached pages associated with a file in the svc_rqst
833  * so that they can be passed to the network sendmsg/sendpage routines
834  * directly. They will be released after the sending has completed.
835  */
836 static int
837 nfsd_splice_actor(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
838 		  struct splice_desc *sd)
839 {
840 	struct svc_rqst *rqstp = sd->u.data;
841 	struct page **pp = rqstp->rq_respages + rqstp->rq_resused;
842 	struct page *page = buf->page;
843 	size_t size;
844 	int ret;
845 
846 	ret = buf->ops->confirm(pipe, buf);
847 	if (unlikely(ret))
848 		return ret;
849 
850 	size = sd->len;
851 
852 	if (rqstp->rq_res.page_len == 0) {
853 		get_page(page);
854 		put_page(*pp);
855 		*pp = page;
856 		rqstp->rq_resused++;
857 		rqstp->rq_res.page_base = buf->offset;
858 		rqstp->rq_res.page_len = size;
859 	} else if (page != pp[-1]) {
860 		get_page(page);
861 		if (*pp)
862 			put_page(*pp);
863 		*pp = page;
864 		rqstp->rq_resused++;
865 		rqstp->rq_res.page_len += size;
866 	} else
867 		rqstp->rq_res.page_len += size;
868 
869 	return size;
870 }
871 
872 static int nfsd_direct_splice_actor(struct pipe_inode_info *pipe,
873 				    struct splice_desc *sd)
874 {
875 	return __splice_from_pipe(pipe, sd, nfsd_splice_actor);
876 }
877 
878 static inline int svc_msnfs(struct svc_fh *ffhp)
879 {
880 #ifdef MSNFS
881 	return (ffhp->fh_export->ex_flags & NFSEXP_MSNFS);
882 #else
883 	return 0;
884 #endif
885 }
886 
887 static __be32
888 nfsd_vfs_read(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
889               loff_t offset, struct kvec *vec, int vlen, unsigned long *count)
890 {
891 	struct inode *inode;
892 	struct raparms	*ra;
893 	mm_segment_t	oldfs;
894 	__be32		err;
895 	int		host_err;
896 
897 	err = nfserr_perm;
898 	inode = file->f_path.dentry->d_inode;
899 
900 	if (svc_msnfs(fhp) && !lock_may_read(inode, offset, *count))
901 		goto out;
902 
903 	/* Get readahead parameters */
904 	ra = nfsd_get_raparms(inode->i_sb->s_dev, inode->i_ino);
905 
906 	if (ra && ra->p_set)
907 		file->f_ra = ra->p_ra;
908 
909 	if (file->f_op->splice_read && rqstp->rq_splice_ok) {
910 		struct splice_desc sd = {
911 			.len		= 0,
912 			.total_len	= *count,
913 			.pos		= offset,
914 			.u.data		= rqstp,
915 		};
916 
917 		rqstp->rq_resused = 1;
918 		host_err = splice_direct_to_actor(file, &sd, nfsd_direct_splice_actor);
919 	} else {
920 		oldfs = get_fs();
921 		set_fs(KERNEL_DS);
922 		host_err = vfs_readv(file, (struct iovec __user *)vec, vlen, &offset);
923 		set_fs(oldfs);
924 	}
925 
926 	/* Write back readahead params */
927 	if (ra) {
928 		struct raparm_hbucket *rab = &raparm_hash[ra->p_hindex];
929 		spin_lock(&rab->pb_lock);
930 		ra->p_ra = file->f_ra;
931 		ra->p_set = 1;
932 		ra->p_count--;
933 		spin_unlock(&rab->pb_lock);
934 	}
935 
936 	if (host_err >= 0) {
937 		nfsdstats.io_read += host_err;
938 		*count = host_err;
939 		err = 0;
940 		fsnotify_access(file->f_path.dentry);
941 	} else
942 		err = nfserrno(host_err);
943 out:
944 	return err;
945 }
946 
947 static void kill_suid(struct dentry *dentry)
948 {
949 	struct iattr	ia;
950 	ia.ia_valid = ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_KILL_PRIV;
951 
952 	mutex_lock(&dentry->d_inode->i_mutex);
953 	notify_change(dentry, &ia);
954 	mutex_unlock(&dentry->d_inode->i_mutex);
955 }
956 
957 static __be32
958 nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
959 				loff_t offset, struct kvec *vec, int vlen,
960 	   			unsigned long cnt, int *stablep)
961 {
962 	struct svc_export	*exp;
963 	struct dentry		*dentry;
964 	struct inode		*inode;
965 	mm_segment_t		oldfs;
966 	__be32			err = 0;
967 	int			host_err;
968 	int			stable = *stablep;
969 
970 #ifdef MSNFS
971 	err = nfserr_perm;
972 
973 	if ((fhp->fh_export->ex_flags & NFSEXP_MSNFS) &&
974 		(!lock_may_write(file->f_path.dentry->d_inode, offset, cnt)))
975 		goto out;
976 #endif
977 
978 	dentry = file->f_path.dentry;
979 	inode = dentry->d_inode;
980 	exp   = fhp->fh_export;
981 
982 	/*
983 	 * Request sync writes if
984 	 *  -	the sync export option has been set, or
985 	 *  -	the client requested O_SYNC behavior (NFSv3 feature).
986 	 *  -   The file system doesn't support fsync().
987 	 * When gathered writes have been configured for this volume,
988 	 * flushing the data to disk is handled separately below.
989 	 */
990 
991 	if (!file->f_op->fsync) {/* COMMIT3 cannot work */
992 	       stable = 2;
993 	       *stablep = 2; /* FILE_SYNC */
994 	}
995 
996 	if (!EX_ISSYNC(exp))
997 		stable = 0;
998 	if (stable && !EX_WGATHER(exp))
999 		file->f_flags |= O_SYNC;
1000 
1001 	/* Write the data. */
1002 	oldfs = get_fs(); set_fs(KERNEL_DS);
1003 	host_err = vfs_writev(file, (struct iovec __user *)vec, vlen, &offset);
1004 	set_fs(oldfs);
1005 	if (host_err >= 0) {
1006 		nfsdstats.io_write += cnt;
1007 		fsnotify_modify(file->f_path.dentry);
1008 	}
1009 
1010 	/* clear setuid/setgid flag after write */
1011 	if (host_err >= 0 && (inode->i_mode & (S_ISUID | S_ISGID)))
1012 		kill_suid(dentry);
1013 
1014 	if (host_err >= 0 && stable) {
1015 		static ino_t	last_ino;
1016 		static dev_t	last_dev;
1017 
1018 		/*
1019 		 * Gathered writes: If another process is currently
1020 		 * writing to the file, there's a high chance
1021 		 * this is another nfsd (triggered by a bulk write
1022 		 * from a client's biod). Rather than syncing the
1023 		 * file with each write request, we sleep for 10 msec.
1024 		 *
1025 		 * I don't know if this roughly approximates
1026 		 * C. Juszak's idea of gathered writes, but it's a
1027 		 * nice and simple solution (IMHO), and it seems to
1028 		 * work:-)
1029 		 */
1030 		if (EX_WGATHER(exp)) {
1031 			if (atomic_read(&inode->i_writecount) > 1
1032 			    || (last_ino == inode->i_ino && last_dev == inode->i_sb->s_dev)) {
1033 				dprintk("nfsd: write defer %d\n", task_pid_nr(current));
1034 				msleep(10);
1035 				dprintk("nfsd: write resume %d\n", task_pid_nr(current));
1036 			}
1037 
1038 			if (inode->i_state & I_DIRTY) {
1039 				dprintk("nfsd: write sync %d\n", task_pid_nr(current));
1040 				host_err=nfsd_sync(file);
1041 			}
1042 #if 0
1043 			wake_up(&inode->i_wait);
1044 #endif
1045 		}
1046 		last_ino = inode->i_ino;
1047 		last_dev = inode->i_sb->s_dev;
1048 	}
1049 
1050 	dprintk("nfsd: write complete host_err=%d\n", host_err);
1051 	if (host_err >= 0)
1052 		err = 0;
1053 	else
1054 		err = nfserrno(host_err);
1055 out:
1056 	return err;
1057 }
1058 
1059 /*
1060  * Read data from a file. count must contain the requested read count
1061  * on entry. On return, *count contains the number of bytes actually read.
1062  * N.B. After this call fhp needs an fh_put
1063  */
1064 __be32
1065 nfsd_read(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
1066 		loff_t offset, struct kvec *vec, int vlen,
1067 		unsigned long *count)
1068 {
1069 	__be32		err;
1070 
1071 	if (file) {
1072 		err = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry,
1073 				NFSD_MAY_READ|NFSD_MAY_OWNER_OVERRIDE);
1074 		if (err)
1075 			goto out;
1076 		err = nfsd_vfs_read(rqstp, fhp, file, offset, vec, vlen, count);
1077 	} else {
1078 		err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
1079 		if (err)
1080 			goto out;
1081 		err = nfsd_vfs_read(rqstp, fhp, file, offset, vec, vlen, count);
1082 		nfsd_close(file);
1083 	}
1084 out:
1085 	return err;
1086 }
1087 
1088 /*
1089  * Write data to a file.
1090  * The stable flag requests synchronous writes.
1091  * N.B. After this call fhp needs an fh_put
1092  */
1093 __be32
1094 nfsd_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
1095 		loff_t offset, struct kvec *vec, int vlen, unsigned long cnt,
1096 		int *stablep)
1097 {
1098 	__be32			err = 0;
1099 
1100 	if (file) {
1101 		err = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry,
1102 				NFSD_MAY_WRITE|NFSD_MAY_OWNER_OVERRIDE);
1103 		if (err)
1104 			goto out;
1105 		err = nfsd_vfs_write(rqstp, fhp, file, offset, vec, vlen, cnt,
1106 				stablep);
1107 	} else {
1108 		err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_WRITE, &file);
1109 		if (err)
1110 			goto out;
1111 
1112 		if (cnt)
1113 			err = nfsd_vfs_write(rqstp, fhp, file, offset, vec, vlen,
1114 					     cnt, stablep);
1115 		nfsd_close(file);
1116 	}
1117 out:
1118 	return err;
1119 }
1120 
1121 #ifdef CONFIG_NFSD_V3
1122 /*
1123  * Commit all pending writes to stable storage.
1124  * Strictly speaking, we could sync just the indicated file region here,
1125  * but there's currently no way we can ask the VFS to do so.
1126  *
1127  * Unfortunately we cannot lock the file to make sure we return full WCC
1128  * data to the client, as locking happens lower down in the filesystem.
1129  */
1130 __be32
1131 nfsd_commit(struct svc_rqst *rqstp, struct svc_fh *fhp,
1132                loff_t offset, unsigned long count)
1133 {
1134 	struct file	*file;
1135 	__be32		err;
1136 
1137 	if ((u64)count > ~(u64)offset)
1138 		return nfserr_inval;
1139 
1140 	err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_WRITE, &file);
1141 	if (err)
1142 		return err;
1143 	if (EX_ISSYNC(fhp->fh_export)) {
1144 		if (file->f_op && file->f_op->fsync) {
1145 			err = nfserrno(nfsd_sync(file));
1146 		} else {
1147 			err = nfserr_notsupp;
1148 		}
1149 	}
1150 
1151 	nfsd_close(file);
1152 	return err;
1153 }
1154 #endif /* CONFIG_NFSD_V3 */
1155 
1156 static __be32
1157 nfsd_create_setattr(struct svc_rqst *rqstp, struct svc_fh *resfhp,
1158 			struct iattr *iap)
1159 {
1160 	/*
1161 	 * Mode has already been set earlier in create:
1162 	 */
1163 	iap->ia_valid &= ~ATTR_MODE;
1164 	/*
1165 	 * Setting uid/gid works only for root.  Irix appears to
1166 	 * send along the gid on create when it tries to implement
1167 	 * setgid directories via NFS:
1168 	 */
1169 	if (current->fsuid != 0)
1170 		iap->ia_valid &= ~(ATTR_UID|ATTR_GID);
1171 	if (iap->ia_valid)
1172 		return nfsd_setattr(rqstp, resfhp, iap, 0, (time_t)0);
1173 	return 0;
1174 }
1175 
1176 /*
1177  * Create a file (regular, directory, device, fifo); UNIX sockets
1178  * not yet implemented.
1179  * If the response fh has been verified, the parent directory should
1180  * already be locked. Note that the parent directory is left locked.
1181  *
1182  * N.B. Every call to nfsd_create needs an fh_put for _both_ fhp and resfhp
1183  */
1184 __be32
1185 nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
1186 		char *fname, int flen, struct iattr *iap,
1187 		int type, dev_t rdev, struct svc_fh *resfhp)
1188 {
1189 	struct dentry	*dentry, *dchild = NULL;
1190 	struct inode	*dirp;
1191 	__be32		err;
1192 	__be32		err2;
1193 	int		host_err;
1194 
1195 	err = nfserr_perm;
1196 	if (!flen)
1197 		goto out;
1198 	err = nfserr_exist;
1199 	if (isdotent(fname, flen))
1200 		goto out;
1201 
1202 	err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE);
1203 	if (err)
1204 		goto out;
1205 
1206 	dentry = fhp->fh_dentry;
1207 	dirp = dentry->d_inode;
1208 
1209 	err = nfserr_notdir;
1210 	if(!dirp->i_op || !dirp->i_op->lookup)
1211 		goto out;
1212 	/*
1213 	 * Check whether the response file handle has been verified yet.
1214 	 * If it has, the parent directory should already be locked.
1215 	 */
1216 	if (!resfhp->fh_dentry) {
1217 		/* called from nfsd_proc_mkdir, or possibly nfsd3_proc_create */
1218 		fh_lock_nested(fhp, I_MUTEX_PARENT);
1219 		dchild = lookup_one_len(fname, dentry, flen);
1220 		host_err = PTR_ERR(dchild);
1221 		if (IS_ERR(dchild))
1222 			goto out_nfserr;
1223 		err = fh_compose(resfhp, fhp->fh_export, dchild, fhp);
1224 		if (err)
1225 			goto out;
1226 	} else {
1227 		/* called from nfsd_proc_create */
1228 		dchild = dget(resfhp->fh_dentry);
1229 		if (!fhp->fh_locked) {
1230 			/* not actually possible */
1231 			printk(KERN_ERR
1232 				"nfsd_create: parent %s/%s not locked!\n",
1233 				dentry->d_parent->d_name.name,
1234 				dentry->d_name.name);
1235 			err = nfserr_io;
1236 			goto out;
1237 		}
1238 	}
1239 	/*
1240 	 * Make sure the child dentry is still negative ...
1241 	 */
1242 	err = nfserr_exist;
1243 	if (dchild->d_inode) {
1244 		dprintk("nfsd_create: dentry %s/%s not negative!\n",
1245 			dentry->d_name.name, dchild->d_name.name);
1246 		goto out;
1247 	}
1248 
1249 	if (!(iap->ia_valid & ATTR_MODE))
1250 		iap->ia_mode = 0;
1251 	iap->ia_mode = (iap->ia_mode & S_IALLUGO) | type;
1252 
1253 	err = nfserr_inval;
1254 	if (!S_ISREG(type) && !S_ISDIR(type) && !special_file(type)) {
1255 		printk(KERN_WARNING "nfsd: bad file type %o in nfsd_create\n",
1256 		       type);
1257 		goto out;
1258 	}
1259 
1260 	host_err = mnt_want_write(fhp->fh_export->ex_path.mnt);
1261 	if (host_err)
1262 		goto out_nfserr;
1263 
1264 	/*
1265 	 * Get the dir op function pointer.
1266 	 */
1267 	err = 0;
1268 	switch (type) {
1269 	case S_IFREG:
1270 		host_err = vfs_create(dirp, dchild, iap->ia_mode, NULL);
1271 		break;
1272 	case S_IFDIR:
1273 		host_err = vfs_mkdir(dirp, dchild, iap->ia_mode);
1274 		break;
1275 	case S_IFCHR:
1276 	case S_IFBLK:
1277 	case S_IFIFO:
1278 	case S_IFSOCK:
1279 		host_err = vfs_mknod(dirp, dchild, iap->ia_mode, rdev);
1280 		break;
1281 	}
1282 	if (host_err < 0) {
1283 		mnt_drop_write(fhp->fh_export->ex_path.mnt);
1284 		goto out_nfserr;
1285 	}
1286 
1287 	if (EX_ISSYNC(fhp->fh_export)) {
1288 		err = nfserrno(nfsd_sync_dir(dentry));
1289 		write_inode_now(dchild->d_inode, 1);
1290 	}
1291 
1292 	err2 = nfsd_create_setattr(rqstp, resfhp, iap);
1293 	if (err2)
1294 		err = err2;
1295 	mnt_drop_write(fhp->fh_export->ex_path.mnt);
1296 	/*
1297 	 * Update the file handle to get the new inode info.
1298 	 */
1299 	if (!err)
1300 		err = fh_update(resfhp);
1301 out:
1302 	if (dchild && !IS_ERR(dchild))
1303 		dput(dchild);
1304 	return err;
1305 
1306 out_nfserr:
1307 	err = nfserrno(host_err);
1308 	goto out;
1309 }
1310 
1311 #ifdef CONFIG_NFSD_V3
1312 /*
1313  * NFSv3 version of nfsd_create
1314  */
1315 __be32
1316 nfsd_create_v3(struct svc_rqst *rqstp, struct svc_fh *fhp,
1317 		char *fname, int flen, struct iattr *iap,
1318 		struct svc_fh *resfhp, int createmode, u32 *verifier,
1319 	        int *truncp, int *created)
1320 {
1321 	struct dentry	*dentry, *dchild = NULL;
1322 	struct inode	*dirp;
1323 	__be32		err;
1324 	__be32		err2;
1325 	int		host_err;
1326 	__u32		v_mtime=0, v_atime=0;
1327 
1328 	err = nfserr_perm;
1329 	if (!flen)
1330 		goto out;
1331 	err = nfserr_exist;
1332 	if (isdotent(fname, flen))
1333 		goto out;
1334 	if (!(iap->ia_valid & ATTR_MODE))
1335 		iap->ia_mode = 0;
1336 	err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE);
1337 	if (err)
1338 		goto out;
1339 
1340 	dentry = fhp->fh_dentry;
1341 	dirp = dentry->d_inode;
1342 
1343 	/* Get all the sanity checks out of the way before
1344 	 * we lock the parent. */
1345 	err = nfserr_notdir;
1346 	if(!dirp->i_op || !dirp->i_op->lookup)
1347 		goto out;
1348 	fh_lock_nested(fhp, I_MUTEX_PARENT);
1349 
1350 	/*
1351 	 * Compose the response file handle.
1352 	 */
1353 	dchild = lookup_one_len(fname, dentry, flen);
1354 	host_err = PTR_ERR(dchild);
1355 	if (IS_ERR(dchild))
1356 		goto out_nfserr;
1357 
1358 	err = fh_compose(resfhp, fhp->fh_export, dchild, fhp);
1359 	if (err)
1360 		goto out;
1361 
1362 	if (createmode == NFS3_CREATE_EXCLUSIVE) {
1363 		/* solaris7 gets confused (bugid 4218508) if these have
1364 		 * the high bit set, so just clear the high bits. If this is
1365 		 * ever changed to use different attrs for storing the
1366 		 * verifier, then do_open_lookup() will also need to be fixed
1367 		 * accordingly.
1368 		 */
1369 		v_mtime = verifier[0]&0x7fffffff;
1370 		v_atime = verifier[1]&0x7fffffff;
1371 	}
1372 
1373 	host_err = mnt_want_write(fhp->fh_export->ex_path.mnt);
1374 	if (host_err)
1375 		goto out_nfserr;
1376 	if (dchild->d_inode) {
1377 		err = 0;
1378 
1379 		switch (createmode) {
1380 		case NFS3_CREATE_UNCHECKED:
1381 			if (! S_ISREG(dchild->d_inode->i_mode))
1382 				err = nfserr_exist;
1383 			else if (truncp) {
1384 				/* in nfsv4, we need to treat this case a little
1385 				 * differently.  we don't want to truncate the
1386 				 * file now; this would be wrong if the OPEN
1387 				 * fails for some other reason.  furthermore,
1388 				 * if the size is nonzero, we should ignore it
1389 				 * according to spec!
1390 				 */
1391 				*truncp = (iap->ia_valid & ATTR_SIZE) && !iap->ia_size;
1392 			}
1393 			else {
1394 				iap->ia_valid &= ATTR_SIZE;
1395 				goto set_attr;
1396 			}
1397 			break;
1398 		case NFS3_CREATE_EXCLUSIVE:
1399 			if (   dchild->d_inode->i_mtime.tv_sec == v_mtime
1400 			    && dchild->d_inode->i_atime.tv_sec == v_atime
1401 			    && dchild->d_inode->i_size  == 0 )
1402 				break;
1403 			 /* fallthru */
1404 		case NFS3_CREATE_GUARDED:
1405 			err = nfserr_exist;
1406 		}
1407 		mnt_drop_write(fhp->fh_export->ex_path.mnt);
1408 		goto out;
1409 	}
1410 
1411 	host_err = vfs_create(dirp, dchild, iap->ia_mode, NULL);
1412 	if (host_err < 0) {
1413 		mnt_drop_write(fhp->fh_export->ex_path.mnt);
1414 		goto out_nfserr;
1415 	}
1416 	if (created)
1417 		*created = 1;
1418 
1419 	if (EX_ISSYNC(fhp->fh_export)) {
1420 		err = nfserrno(nfsd_sync_dir(dentry));
1421 		/* setattr will sync the child (or not) */
1422 	}
1423 
1424 	if (createmode == NFS3_CREATE_EXCLUSIVE) {
1425 		/* Cram the verifier into atime/mtime */
1426 		iap->ia_valid = ATTR_MTIME|ATTR_ATIME
1427 			| ATTR_MTIME_SET|ATTR_ATIME_SET;
1428 		/* XXX someone who knows this better please fix it for nsec */
1429 		iap->ia_mtime.tv_sec = v_mtime;
1430 		iap->ia_atime.tv_sec = v_atime;
1431 		iap->ia_mtime.tv_nsec = 0;
1432 		iap->ia_atime.tv_nsec = 0;
1433 	}
1434 
1435  set_attr:
1436 	err2 = nfsd_create_setattr(rqstp, resfhp, iap);
1437 	if (err2)
1438 		err = err2;
1439 
1440 	mnt_drop_write(fhp->fh_export->ex_path.mnt);
1441 	/*
1442 	 * Update the filehandle to get the new inode info.
1443 	 */
1444 	if (!err)
1445 		err = fh_update(resfhp);
1446 
1447  out:
1448 	fh_unlock(fhp);
1449 	if (dchild && !IS_ERR(dchild))
1450 		dput(dchild);
1451  	return err;
1452 
1453  out_nfserr:
1454 	err = nfserrno(host_err);
1455 	goto out;
1456 }
1457 #endif /* CONFIG_NFSD_V3 */
1458 
1459 /*
1460  * Read a symlink. On entry, *lenp must contain the maximum path length that
1461  * fits into the buffer. On return, it contains the true length.
1462  * N.B. After this call fhp needs an fh_put
1463  */
1464 __be32
1465 nfsd_readlink(struct svc_rqst *rqstp, struct svc_fh *fhp, char *buf, int *lenp)
1466 {
1467 	struct dentry	*dentry;
1468 	struct inode	*inode;
1469 	mm_segment_t	oldfs;
1470 	__be32		err;
1471 	int		host_err;
1472 
1473 	err = fh_verify(rqstp, fhp, S_IFLNK, NFSD_MAY_NOP);
1474 	if (err)
1475 		goto out;
1476 
1477 	dentry = fhp->fh_dentry;
1478 	inode = dentry->d_inode;
1479 
1480 	err = nfserr_inval;
1481 	if (!inode->i_op || !inode->i_op->readlink)
1482 		goto out;
1483 
1484 	touch_atime(fhp->fh_export->ex_path.mnt, dentry);
1485 	/* N.B. Why does this call need a get_fs()??
1486 	 * Remove the set_fs and watch the fireworks:-) --okir
1487 	 */
1488 
1489 	oldfs = get_fs(); set_fs(KERNEL_DS);
1490 	host_err = inode->i_op->readlink(dentry, buf, *lenp);
1491 	set_fs(oldfs);
1492 
1493 	if (host_err < 0)
1494 		goto out_nfserr;
1495 	*lenp = host_err;
1496 	err = 0;
1497 out:
1498 	return err;
1499 
1500 out_nfserr:
1501 	err = nfserrno(host_err);
1502 	goto out;
1503 }
1504 
1505 /*
1506  * Create a symlink and look up its inode
1507  * N.B. After this call _both_ fhp and resfhp need an fh_put
1508  */
1509 __be32
1510 nfsd_symlink(struct svc_rqst *rqstp, struct svc_fh *fhp,
1511 				char *fname, int flen,
1512 				char *path,  int plen,
1513 				struct svc_fh *resfhp,
1514 				struct iattr *iap)
1515 {
1516 	struct dentry	*dentry, *dnew;
1517 	__be32		err, cerr;
1518 	int		host_err;
1519 	umode_t		mode;
1520 
1521 	err = nfserr_noent;
1522 	if (!flen || !plen)
1523 		goto out;
1524 	err = nfserr_exist;
1525 	if (isdotent(fname, flen))
1526 		goto out;
1527 
1528 	err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE);
1529 	if (err)
1530 		goto out;
1531 	fh_lock(fhp);
1532 	dentry = fhp->fh_dentry;
1533 	dnew = lookup_one_len(fname, dentry, flen);
1534 	host_err = PTR_ERR(dnew);
1535 	if (IS_ERR(dnew))
1536 		goto out_nfserr;
1537 
1538 	mode = S_IALLUGO;
1539 	/* Only the MODE ATTRibute is even vaguely meaningful */
1540 	if (iap && (iap->ia_valid & ATTR_MODE))
1541 		mode = iap->ia_mode & S_IALLUGO;
1542 
1543 	host_err = mnt_want_write(fhp->fh_export->ex_path.mnt);
1544 	if (host_err)
1545 		goto out_nfserr;
1546 
1547 	if (unlikely(path[plen] != 0)) {
1548 		char *path_alloced = kmalloc(plen+1, GFP_KERNEL);
1549 		if (path_alloced == NULL)
1550 			host_err = -ENOMEM;
1551 		else {
1552 			strncpy(path_alloced, path, plen);
1553 			path_alloced[plen] = 0;
1554 			host_err = vfs_symlink(dentry->d_inode, dnew, path_alloced, mode);
1555 			kfree(path_alloced);
1556 		}
1557 	} else
1558 		host_err = vfs_symlink(dentry->d_inode, dnew, path, mode);
1559 
1560 	if (!host_err) {
1561 		if (EX_ISSYNC(fhp->fh_export))
1562 			host_err = nfsd_sync_dir(dentry);
1563 	}
1564 	err = nfserrno(host_err);
1565 	fh_unlock(fhp);
1566 
1567 	mnt_drop_write(fhp->fh_export->ex_path.mnt);
1568 
1569 	cerr = fh_compose(resfhp, fhp->fh_export, dnew, fhp);
1570 	dput(dnew);
1571 	if (err==0) err = cerr;
1572 out:
1573 	return err;
1574 
1575 out_nfserr:
1576 	err = nfserrno(host_err);
1577 	goto out;
1578 }
1579 
1580 /*
1581  * Create a hardlink
1582  * N.B. After this call _both_ ffhp and tfhp need an fh_put
1583  */
1584 __be32
1585 nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,
1586 				char *name, int len, struct svc_fh *tfhp)
1587 {
1588 	struct dentry	*ddir, *dnew, *dold;
1589 	struct inode	*dirp, *dest;
1590 	__be32		err;
1591 	int		host_err;
1592 
1593 	err = fh_verify(rqstp, ffhp, S_IFDIR, NFSD_MAY_CREATE);
1594 	if (err)
1595 		goto out;
1596 	err = fh_verify(rqstp, tfhp, -S_IFDIR, NFSD_MAY_NOP);
1597 	if (err)
1598 		goto out;
1599 
1600 	err = nfserr_perm;
1601 	if (!len)
1602 		goto out;
1603 	err = nfserr_exist;
1604 	if (isdotent(name, len))
1605 		goto out;
1606 
1607 	fh_lock_nested(ffhp, I_MUTEX_PARENT);
1608 	ddir = ffhp->fh_dentry;
1609 	dirp = ddir->d_inode;
1610 
1611 	dnew = lookup_one_len(name, ddir, len);
1612 	host_err = PTR_ERR(dnew);
1613 	if (IS_ERR(dnew))
1614 		goto out_nfserr;
1615 
1616 	dold = tfhp->fh_dentry;
1617 	dest = dold->d_inode;
1618 
1619 	host_err = mnt_want_write(tfhp->fh_export->ex_path.mnt);
1620 	if (host_err) {
1621 		err = nfserrno(host_err);
1622 		goto out_dput;
1623 	}
1624 	host_err = vfs_link(dold, dirp, dnew);
1625 	if (!host_err) {
1626 		if (EX_ISSYNC(ffhp->fh_export)) {
1627 			err = nfserrno(nfsd_sync_dir(ddir));
1628 			write_inode_now(dest, 1);
1629 		}
1630 		err = 0;
1631 	} else {
1632 		if (host_err == -EXDEV && rqstp->rq_vers == 2)
1633 			err = nfserr_acces;
1634 		else
1635 			err = nfserrno(host_err);
1636 	}
1637 	mnt_drop_write(tfhp->fh_export->ex_path.mnt);
1638 out_dput:
1639 	dput(dnew);
1640 out_unlock:
1641 	fh_unlock(ffhp);
1642 out:
1643 	return err;
1644 
1645 out_nfserr:
1646 	err = nfserrno(host_err);
1647 	goto out_unlock;
1648 }
1649 
1650 /*
1651  * Rename a file
1652  * N.B. After this call _both_ ffhp and tfhp need an fh_put
1653  */
1654 __be32
1655 nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen,
1656 			    struct svc_fh *tfhp, char *tname, int tlen)
1657 {
1658 	struct dentry	*fdentry, *tdentry, *odentry, *ndentry, *trap;
1659 	struct inode	*fdir, *tdir;
1660 	__be32		err;
1661 	int		host_err;
1662 
1663 	err = fh_verify(rqstp, ffhp, S_IFDIR, NFSD_MAY_REMOVE);
1664 	if (err)
1665 		goto out;
1666 	err = fh_verify(rqstp, tfhp, S_IFDIR, NFSD_MAY_CREATE);
1667 	if (err)
1668 		goto out;
1669 
1670 	fdentry = ffhp->fh_dentry;
1671 	fdir = fdentry->d_inode;
1672 
1673 	tdentry = tfhp->fh_dentry;
1674 	tdir = tdentry->d_inode;
1675 
1676 	err = (rqstp->rq_vers == 2) ? nfserr_acces : nfserr_xdev;
1677 	if (ffhp->fh_export != tfhp->fh_export)
1678 		goto out;
1679 
1680 	err = nfserr_perm;
1681 	if (!flen || isdotent(fname, flen) || !tlen || isdotent(tname, tlen))
1682 		goto out;
1683 
1684 	/* cannot use fh_lock as we need deadlock protective ordering
1685 	 * so do it by hand */
1686 	trap = lock_rename(tdentry, fdentry);
1687 	ffhp->fh_locked = tfhp->fh_locked = 1;
1688 	fill_pre_wcc(ffhp);
1689 	fill_pre_wcc(tfhp);
1690 
1691 	odentry = lookup_one_len(fname, fdentry, flen);
1692 	host_err = PTR_ERR(odentry);
1693 	if (IS_ERR(odentry))
1694 		goto out_nfserr;
1695 
1696 	host_err = -ENOENT;
1697 	if (!odentry->d_inode)
1698 		goto out_dput_old;
1699 	host_err = -EINVAL;
1700 	if (odentry == trap)
1701 		goto out_dput_old;
1702 
1703 	ndentry = lookup_one_len(tname, tdentry, tlen);
1704 	host_err = PTR_ERR(ndentry);
1705 	if (IS_ERR(ndentry))
1706 		goto out_dput_old;
1707 	host_err = -ENOTEMPTY;
1708 	if (ndentry == trap)
1709 		goto out_dput_new;
1710 
1711 	if (svc_msnfs(ffhp) &&
1712 		((atomic_read(&odentry->d_count) > 1)
1713 		 || (atomic_read(&ndentry->d_count) > 1))) {
1714 			host_err = -EPERM;
1715 			goto out_dput_new;
1716 	}
1717 
1718 	host_err = -EXDEV;
1719 	if (ffhp->fh_export->ex_path.mnt != tfhp->fh_export->ex_path.mnt)
1720 		goto out_dput_new;
1721 	host_err = mnt_want_write(ffhp->fh_export->ex_path.mnt);
1722 	if (host_err)
1723 		goto out_dput_new;
1724 
1725 	host_err = vfs_rename(fdir, odentry, tdir, ndentry);
1726 	if (!host_err && EX_ISSYNC(tfhp->fh_export)) {
1727 		host_err = nfsd_sync_dir(tdentry);
1728 		if (!host_err)
1729 			host_err = nfsd_sync_dir(fdentry);
1730 	}
1731 
1732 	mnt_drop_write(ffhp->fh_export->ex_path.mnt);
1733 
1734  out_dput_new:
1735 	dput(ndentry);
1736  out_dput_old:
1737 	dput(odentry);
1738  out_nfserr:
1739 	err = nfserrno(host_err);
1740 
1741 	/* we cannot reply on fh_unlock on the two filehandles,
1742 	 * as that would do the wrong thing if the two directories
1743 	 * were the same, so again we do it by hand
1744 	 */
1745 	fill_post_wcc(ffhp);
1746 	fill_post_wcc(tfhp);
1747 	unlock_rename(tdentry, fdentry);
1748 	ffhp->fh_locked = tfhp->fh_locked = 0;
1749 
1750 out:
1751 	return err;
1752 }
1753 
1754 /*
1755  * Unlink a file or directory
1756  * N.B. After this call fhp needs an fh_put
1757  */
1758 __be32
1759 nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
1760 				char *fname, int flen)
1761 {
1762 	struct dentry	*dentry, *rdentry;
1763 	struct inode	*dirp;
1764 	__be32		err;
1765 	int		host_err;
1766 
1767 	err = nfserr_acces;
1768 	if (!flen || isdotent(fname, flen))
1769 		goto out;
1770 	err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_REMOVE);
1771 	if (err)
1772 		goto out;
1773 
1774 	fh_lock_nested(fhp, I_MUTEX_PARENT);
1775 	dentry = fhp->fh_dentry;
1776 	dirp = dentry->d_inode;
1777 
1778 	rdentry = lookup_one_len(fname, dentry, flen);
1779 	host_err = PTR_ERR(rdentry);
1780 	if (IS_ERR(rdentry))
1781 		goto out_nfserr;
1782 
1783 	if (!rdentry->d_inode) {
1784 		dput(rdentry);
1785 		err = nfserr_noent;
1786 		goto out;
1787 	}
1788 
1789 	if (!type)
1790 		type = rdentry->d_inode->i_mode & S_IFMT;
1791 
1792 	host_err = mnt_want_write(fhp->fh_export->ex_path.mnt);
1793 	if (host_err)
1794 		goto out_nfserr;
1795 
1796 	if (type != S_IFDIR) { /* It's UNLINK */
1797 #ifdef MSNFS
1798 		if ((fhp->fh_export->ex_flags & NFSEXP_MSNFS) &&
1799 			(atomic_read(&rdentry->d_count) > 1)) {
1800 			host_err = -EPERM;
1801 		} else
1802 #endif
1803 		host_err = vfs_unlink(dirp, rdentry);
1804 	} else { /* It's RMDIR */
1805 		host_err = vfs_rmdir(dirp, rdentry);
1806 	}
1807 
1808 	dput(rdentry);
1809 
1810 	if (host_err)
1811 		goto out_drop;
1812 	if (EX_ISSYNC(fhp->fh_export))
1813 		host_err = nfsd_sync_dir(dentry);
1814 
1815 out_drop:
1816 	mnt_drop_write(fhp->fh_export->ex_path.mnt);
1817 out_nfserr:
1818 	err = nfserrno(host_err);
1819 out:
1820 	return err;
1821 }
1822 
1823 /*
1824  * Read entries from a directory.
1825  * The  NFSv3/4 verifier we ignore for now.
1826  */
1827 __be32
1828 nfsd_readdir(struct svc_rqst *rqstp, struct svc_fh *fhp, loff_t *offsetp,
1829 	     struct readdir_cd *cdp, filldir_t func)
1830 {
1831 	__be32		err;
1832 	int 		host_err;
1833 	struct file	*file;
1834 	loff_t		offset = *offsetp;
1835 
1836 	err = nfsd_open(rqstp, fhp, S_IFDIR, NFSD_MAY_READ, &file);
1837 	if (err)
1838 		goto out;
1839 
1840 	offset = vfs_llseek(file, offset, 0);
1841 	if (offset < 0) {
1842 		err = nfserrno((int)offset);
1843 		goto out_close;
1844 	}
1845 
1846 	/*
1847 	 * Read the directory entries. This silly loop is necessary because
1848 	 * readdir() is not guaranteed to fill up the entire buffer, but
1849 	 * may choose to do less.
1850 	 */
1851 
1852 	do {
1853 		cdp->err = nfserr_eof; /* will be cleared on successful read */
1854 		host_err = vfs_readdir(file, func, cdp);
1855 	} while (host_err >=0 && cdp->err == nfs_ok);
1856 	if (host_err)
1857 		err = nfserrno(host_err);
1858 	else
1859 		err = cdp->err;
1860 	*offsetp = vfs_llseek(file, 0, 1);
1861 
1862 	if (err == nfserr_eof || err == nfserr_toosmall)
1863 		err = nfs_ok; /* can still be found in ->err */
1864 out_close:
1865 	nfsd_close(file);
1866 out:
1867 	return err;
1868 }
1869 
1870 /*
1871  * Get file system stats
1872  * N.B. After this call fhp needs an fh_put
1873  */
1874 __be32
1875 nfsd_statfs(struct svc_rqst *rqstp, struct svc_fh *fhp, struct kstatfs *stat)
1876 {
1877 	__be32 err = fh_verify(rqstp, fhp, 0, NFSD_MAY_NOP);
1878 	if (!err && vfs_statfs(fhp->fh_dentry,stat))
1879 		err = nfserr_io;
1880 	return err;
1881 }
1882 
1883 static int exp_rdonly(struct svc_rqst *rqstp, struct svc_export *exp)
1884 {
1885 	return nfsexp_flags(rqstp, exp) & NFSEXP_READONLY;
1886 }
1887 
1888 /*
1889  * Check for a user's access permissions to this inode.
1890  */
1891 __be32
1892 nfsd_permission(struct svc_rqst *rqstp, struct svc_export *exp,
1893 					struct dentry *dentry, int acc)
1894 {
1895 	struct inode	*inode = dentry->d_inode;
1896 	int		err;
1897 
1898 	if (acc == NFSD_MAY_NOP)
1899 		return 0;
1900 #if 0
1901 	dprintk("nfsd: permission 0x%x%s%s%s%s%s%s%s mode 0%o%s%s%s\n",
1902 		acc,
1903 		(acc & NFSD_MAY_READ)?	" read"  : "",
1904 		(acc & NFSD_MAY_WRITE)?	" write" : "",
1905 		(acc & NFSD_MAY_EXEC)?	" exec"  : "",
1906 		(acc & NFSD_MAY_SATTR)?	" sattr" : "",
1907 		(acc & NFSD_MAY_TRUNC)?	" trunc" : "",
1908 		(acc & NFSD_MAY_LOCK)?	" lock"  : "",
1909 		(acc & NFSD_MAY_OWNER_OVERRIDE)? " owneroverride" : "",
1910 		inode->i_mode,
1911 		IS_IMMUTABLE(inode)?	" immut" : "",
1912 		IS_APPEND(inode)?	" append" : "",
1913 		__mnt_is_readonly(exp->ex_path.mnt)?	" ro" : "");
1914 	dprintk("      owner %d/%d user %d/%d\n",
1915 		inode->i_uid, inode->i_gid, current->fsuid, current->fsgid);
1916 #endif
1917 
1918 	/* Normally we reject any write/sattr etc access on a read-only file
1919 	 * system.  But if it is IRIX doing check on write-access for a
1920 	 * device special file, we ignore rofs.
1921 	 */
1922 	if (!(acc & NFSD_MAY_LOCAL_ACCESS))
1923 		if (acc & (NFSD_MAY_WRITE | NFSD_MAY_SATTR | NFSD_MAY_TRUNC)) {
1924 			if (exp_rdonly(rqstp, exp) ||
1925 			    __mnt_is_readonly(exp->ex_path.mnt))
1926 				return nfserr_rofs;
1927 			if (/* (acc & NFSD_MAY_WRITE) && */ IS_IMMUTABLE(inode))
1928 				return nfserr_perm;
1929 		}
1930 	if ((acc & NFSD_MAY_TRUNC) && IS_APPEND(inode))
1931 		return nfserr_perm;
1932 
1933 	if (acc & NFSD_MAY_LOCK) {
1934 		/* If we cannot rely on authentication in NLM requests,
1935 		 * just allow locks, otherwise require read permission, or
1936 		 * ownership
1937 		 */
1938 		if (exp->ex_flags & NFSEXP_NOAUTHNLM)
1939 			return 0;
1940 		else
1941 			acc = NFSD_MAY_READ | NFSD_MAY_OWNER_OVERRIDE;
1942 	}
1943 	/*
1944 	 * The file owner always gets access permission for accesses that
1945 	 * would normally be checked at open time. This is to make
1946 	 * file access work even when the client has done a fchmod(fd, 0).
1947 	 *
1948 	 * However, `cp foo bar' should fail nevertheless when bar is
1949 	 * readonly. A sensible way to do this might be to reject all
1950 	 * attempts to truncate a read-only file, because a creat() call
1951 	 * always implies file truncation.
1952 	 * ... but this isn't really fair.  A process may reasonably call
1953 	 * ftruncate on an open file descriptor on a file with perm 000.
1954 	 * We must trust the client to do permission checking - using "ACCESS"
1955 	 * with NFSv3.
1956 	 */
1957 	if ((acc & NFSD_MAY_OWNER_OVERRIDE) &&
1958 	    inode->i_uid == current->fsuid)
1959 		return 0;
1960 
1961 	/* This assumes  NFSD_MAY_{READ,WRITE,EXEC} == MAY_{READ,WRITE,EXEC} */
1962 	err = permission(inode, acc & (MAY_READ|MAY_WRITE|MAY_EXEC), NULL);
1963 
1964 	/* Allow read access to binaries even when mode 111 */
1965 	if (err == -EACCES && S_ISREG(inode->i_mode) &&
1966 	    acc == (NFSD_MAY_READ | NFSD_MAY_OWNER_OVERRIDE))
1967 		err = permission(inode, MAY_EXEC, NULL);
1968 
1969 	return err? nfserrno(err) : 0;
1970 }
1971 
1972 void
1973 nfsd_racache_shutdown(void)
1974 {
1975 	if (!raparml)
1976 		return;
1977 	dprintk("nfsd: freeing readahead buffers.\n");
1978 	kfree(raparml);
1979 	raparml = NULL;
1980 }
1981 /*
1982  * Initialize readahead param cache
1983  */
1984 int
1985 nfsd_racache_init(int cache_size)
1986 {
1987 	int	i;
1988 	int	j = 0;
1989 	int	nperbucket;
1990 
1991 
1992 	if (raparml)
1993 		return 0;
1994 	if (cache_size < 2*RAPARM_HASH_SIZE)
1995 		cache_size = 2*RAPARM_HASH_SIZE;
1996 	raparml = kcalloc(cache_size, sizeof(struct raparms), GFP_KERNEL);
1997 
1998 	if (!raparml) {
1999 		printk(KERN_WARNING
2000 			"nfsd: Could not allocate memory read-ahead cache.\n");
2001 		return -ENOMEM;
2002 	}
2003 
2004 	dprintk("nfsd: allocating %d readahead buffers.\n", cache_size);
2005 	for (i = 0 ; i < RAPARM_HASH_SIZE ; i++) {
2006 		raparm_hash[i].pb_head = NULL;
2007 		spin_lock_init(&raparm_hash[i].pb_lock);
2008 	}
2009 	nperbucket = DIV_ROUND_UP(cache_size, RAPARM_HASH_SIZE);
2010 	for (i = 0; i < cache_size - 1; i++) {
2011 		if (i % nperbucket == 0)
2012 			raparm_hash[j++].pb_head = raparml + i;
2013 		if (i % nperbucket < nperbucket-1)
2014 			raparml[i].p_next = raparml + i + 1;
2015 	}
2016 
2017 	nfsdstats.ra_size = cache_size;
2018 	return 0;
2019 }
2020 
2021 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
2022 struct posix_acl *
2023 nfsd_get_posix_acl(struct svc_fh *fhp, int type)
2024 {
2025 	struct inode *inode = fhp->fh_dentry->d_inode;
2026 	char *name;
2027 	void *value = NULL;
2028 	ssize_t size;
2029 	struct posix_acl *acl;
2030 
2031 	if (!IS_POSIXACL(inode))
2032 		return ERR_PTR(-EOPNOTSUPP);
2033 
2034 	switch (type) {
2035 	case ACL_TYPE_ACCESS:
2036 		name = POSIX_ACL_XATTR_ACCESS;
2037 		break;
2038 	case ACL_TYPE_DEFAULT:
2039 		name = POSIX_ACL_XATTR_DEFAULT;
2040 		break;
2041 	default:
2042 		return ERR_PTR(-EOPNOTSUPP);
2043 	}
2044 
2045 	size = nfsd_getxattr(fhp->fh_dentry, name, &value);
2046 	if (size < 0)
2047 		return ERR_PTR(size);
2048 
2049 	acl = posix_acl_from_xattr(value, size);
2050 	kfree(value);
2051 	return acl;
2052 }
2053 
2054 int
2055 nfsd_set_posix_acl(struct svc_fh *fhp, int type, struct posix_acl *acl)
2056 {
2057 	struct inode *inode = fhp->fh_dentry->d_inode;
2058 	char *name;
2059 	void *value = NULL;
2060 	size_t size;
2061 	int error;
2062 
2063 	if (!IS_POSIXACL(inode) || !inode->i_op ||
2064 	    !inode->i_op->setxattr || !inode->i_op->removexattr)
2065 		return -EOPNOTSUPP;
2066 	switch(type) {
2067 		case ACL_TYPE_ACCESS:
2068 			name = POSIX_ACL_XATTR_ACCESS;
2069 			break;
2070 		case ACL_TYPE_DEFAULT:
2071 			name = POSIX_ACL_XATTR_DEFAULT;
2072 			break;
2073 		default:
2074 			return -EOPNOTSUPP;
2075 	}
2076 
2077 	if (acl && acl->a_count) {
2078 		size = posix_acl_xattr_size(acl->a_count);
2079 		value = kmalloc(size, GFP_KERNEL);
2080 		if (!value)
2081 			return -ENOMEM;
2082 		error = posix_acl_to_xattr(acl, value, size);
2083 		if (error < 0)
2084 			goto getout;
2085 		size = error;
2086 	} else
2087 		size = 0;
2088 
2089 	error = mnt_want_write(fhp->fh_export->ex_path.mnt);
2090 	if (error)
2091 		goto getout;
2092 	if (size)
2093 		error = vfs_setxattr(fhp->fh_dentry, name, value, size, 0);
2094 	else {
2095 		if (!S_ISDIR(inode->i_mode) && type == ACL_TYPE_DEFAULT)
2096 			error = 0;
2097 		else {
2098 			error = vfs_removexattr(fhp->fh_dentry, name);
2099 			if (error == -ENODATA)
2100 				error = 0;
2101 		}
2102 	}
2103 	mnt_drop_write(fhp->fh_export->ex_path.mnt);
2104 
2105 getout:
2106 	kfree(value);
2107 	return error;
2108 }
2109 #endif  /* defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) */
2110