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