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