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