1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#include <linux/fs.h>
17#include <linux/file.h>
18#include <linux/splice.h>
19#include <linux/falloc.h>
20#include <linux/fcntl.h>
21#include <linux/namei.h>
22#include <linux/delay.h>
23#include <linux/fsnotify.h>
24#include <linux/posix_acl_xattr.h>
25#include <linux/xattr.h>
26#include <linux/jhash.h>
27#include <linux/ima.h>
28#include <linux/slab.h>
29#include <asm/uaccess.h>
30#include <linux/exportfs.h>
31#include <linux/writeback.h>
32#include <linux/security.h>
33
34#ifdef CONFIG_NFSD_V3
35#include "xdr3.h"
36#endif
37
38#ifdef CONFIG_NFSD_V4
39#include "../internal.h"
40#include "acl.h"
41#include "idmap.h"
42#endif
43
44#include "nfsd.h"
45#include "vfs.h"
46#include "trace.h"
47
48#define NFSDDBG_FACILITY NFSDDBG_FILEOP
49
50
51
52
53
54
55
56
57
58struct raparms {
59 struct raparms *p_next;
60 unsigned int p_count;
61 ino_t p_ino;
62 dev_t p_dev;
63 int p_set;
64 struct file_ra_state p_ra;
65 unsigned int p_hindex;
66};
67
68struct raparm_hbucket {
69 struct raparms *pb_head;
70 spinlock_t pb_lock;
71} ____cacheline_aligned_in_smp;
72
73#define RAPARM_HASH_BITS 4
74#define RAPARM_HASH_SIZE (1<<RAPARM_HASH_BITS)
75#define RAPARM_HASH_MASK (RAPARM_HASH_SIZE-1)
76static struct raparm_hbucket raparm_hash[RAPARM_HASH_SIZE];
77
78
79
80
81
82
83
84int
85nfsd_cross_mnt(struct svc_rqst *rqstp, struct dentry **dpp,
86 struct svc_export **expp)
87{
88 struct svc_export *exp = *expp, *exp2 = NULL;
89 struct dentry *dentry = *dpp;
90 struct path path = {.mnt = mntget(exp->ex_path.mnt),
91 .dentry = dget(dentry)};
92 int err = 0;
93
94 err = follow_down(&path);
95 if (err < 0)
96 goto out;
97
98 exp2 = rqst_exp_get_by_name(rqstp, &path);
99 if (IS_ERR(exp2)) {
100 err = PTR_ERR(exp2);
101
102
103
104
105
106
107
108 if (err == -ENOENT && !(exp->ex_flags & NFSEXP_V4ROOT))
109 err = 0;
110 path_put(&path);
111 goto out;
112 }
113 if (nfsd_v4client(rqstp) ||
114 (exp->ex_flags & NFSEXP_CROSSMOUNT) || EX_NOHIDE(exp2)) {
115
116
117
118
119
120
121
122 *dpp = path.dentry;
123 path.dentry = dentry;
124 *expp = exp2;
125 exp2 = exp;
126 }
127 path_put(&path);
128 exp_put(exp2);
129out:
130 return err;
131}
132
133static void follow_to_parent(struct path *path)
134{
135 struct dentry *dp;
136
137 while (path->dentry == path->mnt->mnt_root && follow_up(path))
138 ;
139 dp = dget_parent(path->dentry);
140 dput(path->dentry);
141 path->dentry = dp;
142}
143
144static int nfsd_lookup_parent(struct svc_rqst *rqstp, struct dentry *dparent, struct svc_export **exp, struct dentry **dentryp)
145{
146 struct svc_export *exp2;
147 struct path path = {.mnt = mntget((*exp)->ex_path.mnt),
148 .dentry = dget(dparent)};
149
150 follow_to_parent(&path);
151
152 exp2 = rqst_exp_parent(rqstp, &path);
153 if (PTR_ERR(exp2) == -ENOENT) {
154 *dentryp = dget(dparent);
155 } else if (IS_ERR(exp2)) {
156 path_put(&path);
157 return PTR_ERR(exp2);
158 } else {
159 *dentryp = dget(path.dentry);
160 exp_put(*exp);
161 *exp = exp2;
162 }
163 path_put(&path);
164 return 0;
165}
166
167
168
169
170
171int nfsd_mountpoint(struct dentry *dentry, struct svc_export *exp)
172{
173 if (d_mountpoint(dentry))
174 return 1;
175 if (nfsd4_is_junction(dentry))
176 return 1;
177 if (!(exp->ex_flags & NFSEXP_V4ROOT))
178 return 0;
179 return d_inode(dentry) != NULL;
180}
181
182__be32
183nfsd_lookup_dentry(struct svc_rqst *rqstp, struct svc_fh *fhp,
184 const char *name, unsigned int len,
185 struct svc_export **exp_ret, struct dentry **dentry_ret)
186{
187 struct svc_export *exp;
188 struct dentry *dparent;
189 struct dentry *dentry;
190 int host_err;
191
192 dprintk("nfsd: nfsd_lookup(fh %s, %.*s)\n", SVCFH_fmt(fhp), len,name);
193
194 dparent = fhp->fh_dentry;
195 exp = exp_get(fhp->fh_export);
196
197
198 if (isdotent(name, len)) {
199 if (len==1)
200 dentry = dget(dparent);
201 else if (dparent != exp->ex_path.dentry)
202 dentry = dget_parent(dparent);
203 else if (!EX_NOHIDE(exp) && !nfsd_v4client(rqstp))
204 dentry = dget(dparent);
205 else {
206
207 host_err = nfsd_lookup_parent(rqstp, dparent, &exp, &dentry);
208 if (host_err)
209 goto out_nfserr;
210 }
211 } else {
212
213
214
215
216
217 fh_lock_nested(fhp, I_MUTEX_PARENT);
218 dentry = lookup_one_len(name, dparent, len);
219 host_err = PTR_ERR(dentry);
220 if (IS_ERR(dentry))
221 goto out_nfserr;
222 if (nfsd_mountpoint(dentry, exp)) {
223
224
225
226
227
228
229
230
231 fh_unlock(fhp);
232 if ((host_err = nfsd_cross_mnt(rqstp, &dentry, &exp))) {
233 dput(dentry);
234 goto out_nfserr;
235 }
236 }
237 }
238 *dentry_ret = dentry;
239 *exp_ret = exp;
240 return 0;
241
242out_nfserr:
243 exp_put(exp);
244 return nfserrno(host_err);
245}
246
247
248
249
250
251
252
253
254
255
256
257
258
259__be32
260nfsd_lookup(struct svc_rqst *rqstp, struct svc_fh *fhp, const char *name,
261 unsigned int len, struct svc_fh *resfh)
262{
263 struct svc_export *exp;
264 struct dentry *dentry;
265 __be32 err;
266
267 err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_EXEC);
268 if (err)
269 return err;
270 err = nfsd_lookup_dentry(rqstp, fhp, name, len, &exp, &dentry);
271 if (err)
272 return err;
273 err = check_nfsd_access(exp, rqstp);
274 if (err)
275 goto out;
276
277
278
279
280 err = fh_compose(resfh, exp, dentry, fhp);
281 if (!err && d_really_is_negative(dentry))
282 err = nfserr_noent;
283out:
284 dput(dentry);
285 exp_put(exp);
286 return err;
287}
288
289
290
291
292static int
293commit_metadata(struct svc_fh *fhp)
294{
295 struct inode *inode = d_inode(fhp->fh_dentry);
296 const struct export_operations *export_ops = inode->i_sb->s_export_op;
297
298 if (!EX_ISSYNC(fhp->fh_export))
299 return 0;
300
301 if (export_ops->commit_metadata)
302 return export_ops->commit_metadata(inode);
303 return sync_inode_metadata(inode, 1);
304}
305
306
307
308
309
310static void
311nfsd_sanitize_attrs(struct inode *inode, struct iattr *iap)
312{
313
314 if (iap->ia_valid & ATTR_MODE) {
315 iap->ia_mode &= S_IALLUGO;
316 iap->ia_mode |= (inode->i_mode & ~S_IALLUGO);
317 }
318
319
320 if (!S_ISDIR(inode->i_mode) &&
321 ((iap->ia_valid & ATTR_UID) || (iap->ia_valid & ATTR_GID))) {
322 iap->ia_valid |= ATTR_KILL_PRIV;
323 if (iap->ia_valid & ATTR_MODE) {
324
325 iap->ia_mode &= ~S_ISUID;
326 if (iap->ia_mode & S_IXGRP)
327 iap->ia_mode &= ~S_ISGID;
328 } else {
329
330 iap->ia_valid |= (ATTR_KILL_SUID | ATTR_KILL_SGID);
331 }
332 }
333}
334
335static __be32
336nfsd_get_write_access(struct svc_rqst *rqstp, struct svc_fh *fhp,
337 struct iattr *iap)
338{
339 struct inode *inode = d_inode(fhp->fh_dentry);
340 int host_err;
341
342 if (iap->ia_size < inode->i_size) {
343 __be32 err;
344
345 err = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry,
346 NFSD_MAY_TRUNC | NFSD_MAY_OWNER_OVERRIDE);
347 if (err)
348 return err;
349 }
350
351 host_err = get_write_access(inode);
352 if (host_err)
353 goto out_nfserrno;
354
355 host_err = locks_verify_truncate(inode, NULL, iap->ia_size);
356 if (host_err)
357 goto out_put_write_access;
358 return 0;
359
360out_put_write_access:
361 put_write_access(inode);
362out_nfserrno:
363 return nfserrno(host_err);
364}
365
366
367
368
369__be32
370nfsd_setattr(struct svc_rqst *rqstp, struct svc_fh *fhp, struct iattr *iap,
371 int check_guard, time_t guardtime)
372{
373 struct dentry *dentry;
374 struct inode *inode;
375 int accmode = NFSD_MAY_SATTR;
376 umode_t ftype = 0;
377 __be32 err;
378 int host_err;
379 bool get_write_count;
380 int size_change = 0;
381
382 if (iap->ia_valid & (ATTR_ATIME | ATTR_MTIME | ATTR_SIZE))
383 accmode |= NFSD_MAY_WRITE|NFSD_MAY_OWNER_OVERRIDE;
384 if (iap->ia_valid & ATTR_SIZE)
385 ftype = S_IFREG;
386
387
388 get_write_count = !fhp->fh_dentry;
389
390
391 err = fh_verify(rqstp, fhp, ftype, accmode);
392 if (err)
393 goto out;
394 if (get_write_count) {
395 host_err = fh_want_write(fhp);
396 if (host_err)
397 return nfserrno(host_err);
398 }
399
400 dentry = fhp->fh_dentry;
401 inode = d_inode(dentry);
402
403
404 if (S_ISLNK(inode->i_mode))
405 iap->ia_valid &= ~ATTR_MODE;
406
407 if (!iap->ia_valid)
408 goto out;
409
410 nfsd_sanitize_attrs(inode, iap);
411
412
413
414
415
416 if (iap->ia_valid & ATTR_SIZE) {
417 err = nfsd_get_write_access(rqstp, fhp, iap);
418 if (err)
419 goto out;
420 size_change = 1;
421
422
423
424
425
426
427
428
429 if (iap->ia_size != i_size_read(inode))
430 iap->ia_valid |= ATTR_MTIME;
431 }
432
433 iap->ia_valid |= ATTR_CTIME;
434
435 if (check_guard && guardtime != inode->i_ctime.tv_sec) {
436 err = nfserr_notsync;
437 goto out_put_write_access;
438 }
439
440 fh_lock(fhp);
441 host_err = notify_change(dentry, iap, NULL);
442 fh_unlock(fhp);
443 err = nfserrno(host_err);
444
445out_put_write_access:
446 if (size_change)
447 put_write_access(inode);
448 if (!err)
449 err = nfserrno(commit_metadata(fhp));
450out:
451 return err;
452}
453
454#if defined(CONFIG_NFSD_V4)
455
456
457
458#define NFSD_JUNCTION_XATTR_NAME XATTR_TRUSTED_PREFIX "junction.nfs"
459
460
461
462
463
464
465
466
467
468int nfsd4_is_junction(struct dentry *dentry)
469{
470 struct inode *inode = d_inode(dentry);
471
472 if (inode == NULL)
473 return 0;
474 if (inode->i_mode & S_IXUGO)
475 return 0;
476 if (!(inode->i_mode & S_ISVTX))
477 return 0;
478 if (vfs_getxattr(dentry, NFSD_JUNCTION_XATTR_NAME, NULL, 0) <= 0)
479 return 0;
480 return 1;
481}
482#ifdef CONFIG_NFSD_V4_SECURITY_LABEL
483__be32 nfsd4_set_nfs4_label(struct svc_rqst *rqstp, struct svc_fh *fhp,
484 struct xdr_netobj *label)
485{
486 __be32 error;
487 int host_error;
488 struct dentry *dentry;
489
490 error = fh_verify(rqstp, fhp, 0 , NFSD_MAY_SATTR);
491 if (error)
492 return error;
493
494 dentry = fhp->fh_dentry;
495
496 inode_lock(d_inode(dentry));
497 host_error = security_inode_setsecctx(dentry, label->data, label->len);
498 inode_unlock(d_inode(dentry));
499 return nfserrno(host_error);
500}
501#else
502__be32 nfsd4_set_nfs4_label(struct svc_rqst *rqstp, struct svc_fh *fhp,
503 struct xdr_netobj *label)
504{
505 return nfserr_notsupp;
506}
507#endif
508
509__be32 nfsd4_clone_file_range(struct file *src, u64 src_pos, struct file *dst,
510 u64 dst_pos, u64 count)
511{
512 return nfserrno(vfs_clone_file_range(src, src_pos, dst, dst_pos,
513 count));
514}
515
516__be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp,
517 struct file *file, loff_t offset, loff_t len,
518 int flags)
519{
520 int error;
521
522 if (!S_ISREG(file_inode(file)->i_mode))
523 return nfserr_inval;
524
525 error = vfs_fallocate(file, flags, offset, len);
526 if (!error)
527 error = commit_metadata(fhp);
528
529 return nfserrno(error);
530}
531#endif
532
533#ifdef CONFIG_NFSD_V3
534
535
536
537struct accessmap {
538 u32 access;
539 int how;
540};
541static struct accessmap nfs3_regaccess[] = {
542 { NFS3_ACCESS_READ, NFSD_MAY_READ },
543 { NFS3_ACCESS_EXECUTE, NFSD_MAY_EXEC },
544 { NFS3_ACCESS_MODIFY, NFSD_MAY_WRITE|NFSD_MAY_TRUNC },
545 { NFS3_ACCESS_EXTEND, NFSD_MAY_WRITE },
546
547 { 0, 0 }
548};
549
550static struct accessmap nfs3_diraccess[] = {
551 { NFS3_ACCESS_READ, NFSD_MAY_READ },
552 { NFS3_ACCESS_LOOKUP, NFSD_MAY_EXEC },
553 { NFS3_ACCESS_MODIFY, NFSD_MAY_EXEC|NFSD_MAY_WRITE|NFSD_MAY_TRUNC},
554 { NFS3_ACCESS_EXTEND, NFSD_MAY_EXEC|NFSD_MAY_WRITE },
555 { NFS3_ACCESS_DELETE, NFSD_MAY_REMOVE },
556
557 { 0, 0 }
558};
559
560static struct accessmap nfs3_anyaccess[] = {
561
562
563
564
565
566
567
568 { NFS3_ACCESS_READ, NFSD_MAY_READ },
569 { NFS3_ACCESS_EXECUTE, NFSD_MAY_EXEC },
570 { NFS3_ACCESS_MODIFY, NFSD_MAY_WRITE|NFSD_MAY_LOCAL_ACCESS },
571 { NFS3_ACCESS_EXTEND, NFSD_MAY_WRITE|NFSD_MAY_LOCAL_ACCESS },
572
573 { 0, 0 }
574};
575
576__be32
577nfsd_access(struct svc_rqst *rqstp, struct svc_fh *fhp, u32 *access, u32 *supported)
578{
579 struct accessmap *map;
580 struct svc_export *export;
581 struct dentry *dentry;
582 u32 query, result = 0, sresult = 0;
583 __be32 error;
584
585 error = fh_verify(rqstp, fhp, 0, NFSD_MAY_NOP);
586 if (error)
587 goto out;
588
589 export = fhp->fh_export;
590 dentry = fhp->fh_dentry;
591
592 if (d_is_reg(dentry))
593 map = nfs3_regaccess;
594 else if (d_is_dir(dentry))
595 map = nfs3_diraccess;
596 else
597 map = nfs3_anyaccess;
598
599
600 query = *access;
601 for (; map->access; map++) {
602 if (map->access & query) {
603 __be32 err2;
604
605 sresult |= map->access;
606
607 err2 = nfsd_permission(rqstp, export, dentry, map->how);
608 switch (err2) {
609 case nfs_ok:
610 result |= map->access;
611 break;
612
613
614
615 case nfserr_rofs:
616 case nfserr_acces:
617 case nfserr_perm:
618
619 break;
620 default:
621 error = err2;
622 goto out;
623 }
624 }
625 }
626 *access = result;
627 if (supported)
628 *supported = sresult;
629
630 out:
631 return error;
632}
633#endif
634
635static int nfsd_open_break_lease(struct inode *inode, int access)
636{
637 unsigned int mode;
638
639 if (access & NFSD_MAY_NOT_BREAK_LEASE)
640 return 0;
641 mode = (access & NFSD_MAY_WRITE) ? O_WRONLY : O_RDONLY;
642 return break_lease(inode, mode | O_NONBLOCK);
643}
644
645
646
647
648
649
650
651__be32
652nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, umode_t type,
653 int may_flags, struct file **filp)
654{
655 struct path path;
656 struct inode *inode;
657 struct file *file;
658 int flags = O_RDONLY|O_LARGEFILE;
659 __be32 err;
660 int host_err = 0;
661
662 validate_process_creds();
663
664
665
666
667
668
669
670
671
672
673
674
675 if (type == S_IFREG)
676 may_flags |= NFSD_MAY_OWNER_OVERRIDE;
677 err = fh_verify(rqstp, fhp, type, may_flags);
678 if (err)
679 goto out;
680
681 path.mnt = fhp->fh_export->ex_path.mnt;
682 path.dentry = fhp->fh_dentry;
683 inode = d_inode(path.dentry);
684
685
686
687
688 err = nfserr_perm;
689 if (IS_APPEND(inode) && (may_flags & NFSD_MAY_WRITE))
690 goto out;
691
692
693
694
695
696 if (S_ISREG((inode)->i_mode) && mandatory_lock(inode))
697 goto out;
698
699 if (!inode->i_fop)
700 goto out;
701
702 host_err = nfsd_open_break_lease(inode, may_flags);
703 if (host_err)
704 goto out_nfserr;
705
706 if (may_flags & NFSD_MAY_WRITE) {
707 if (may_flags & NFSD_MAY_READ)
708 flags = O_RDWR|O_LARGEFILE;
709 else
710 flags = O_WRONLY|O_LARGEFILE;
711 }
712
713 file = dentry_open(&path, flags, current_cred());
714 if (IS_ERR(file)) {
715 host_err = PTR_ERR(file);
716 goto out_nfserr;
717 }
718
719 host_err = ima_file_check(file, may_flags, 0);
720 if (host_err) {
721 fput(file);
722 goto out_nfserr;
723 }
724
725 if (may_flags & NFSD_MAY_64BIT_COOKIE)
726 file->f_mode |= FMODE_64BITHASH;
727 else
728 file->f_mode |= FMODE_32BITHASH;
729
730 *filp = file;
731out_nfserr:
732 err = nfserrno(host_err);
733out:
734 validate_process_creds();
735 return err;
736}
737
738struct raparms *
739nfsd_init_raparms(struct file *file)
740{
741 struct inode *inode = file_inode(file);
742 dev_t dev = inode->i_sb->s_dev;
743 ino_t ino = inode->i_ino;
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;
771found:
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
781 if (ra->p_set)
782 file->f_ra = ra->p_ra;
783 return ra;
784}
785
786void nfsd_put_raparams(struct file *file, struct raparms *ra)
787{
788 struct raparm_hbucket *rab = &raparm_hash[ra->p_hindex];
789
790 spin_lock(&rab->pb_lock);
791 ra->p_ra = file->f_ra;
792 ra->p_set = 1;
793 ra->p_count--;
794 spin_unlock(&rab->pb_lock);
795}
796
797
798
799
800
801
802static int
803nfsd_splice_actor(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
804 struct splice_desc *sd)
805{
806 struct svc_rqst *rqstp = sd->u.data;
807 struct page **pp = rqstp->rq_next_page;
808 struct page *page = buf->page;
809 size_t size;
810
811 size = sd->len;
812
813 if (rqstp->rq_res.page_len == 0) {
814 get_page(page);
815 put_page(*rqstp->rq_next_page);
816 *(rqstp->rq_next_page++) = page;
817 rqstp->rq_res.page_base = buf->offset;
818 rqstp->rq_res.page_len = size;
819 } else if (page != pp[-1]) {
820 get_page(page);
821 if (*rqstp->rq_next_page)
822 put_page(*rqstp->rq_next_page);
823 *(rqstp->rq_next_page++) = page;
824 rqstp->rq_res.page_len += size;
825 } else
826 rqstp->rq_res.page_len += size;
827
828 return size;
829}
830
831static int nfsd_direct_splice_actor(struct pipe_inode_info *pipe,
832 struct splice_desc *sd)
833{
834 return __splice_from_pipe(pipe, sd, nfsd_splice_actor);
835}
836
837static __be32
838nfsd_finish_read(struct file *file, unsigned long *count, int host_err)
839{
840 if (host_err >= 0) {
841 nfsdstats.io_read += host_err;
842 *count = host_err;
843 fsnotify_access(file);
844 return 0;
845 } else
846 return nfserrno(host_err);
847}
848
849__be32 nfsd_splice_read(struct svc_rqst *rqstp,
850 struct file *file, loff_t offset, unsigned long *count)
851{
852 struct splice_desc sd = {
853 .len = 0,
854 .total_len = *count,
855 .pos = offset,
856 .u.data = rqstp,
857 };
858 int host_err;
859
860 rqstp->rq_next_page = rqstp->rq_respages + 1;
861 host_err = splice_direct_to_actor(file, &sd, nfsd_direct_splice_actor);
862 return nfsd_finish_read(file, count, host_err);
863}
864
865__be32 nfsd_readv(struct file *file, loff_t offset, struct kvec *vec, int vlen,
866 unsigned long *count)
867{
868 mm_segment_t oldfs;
869 int host_err;
870
871 oldfs = get_fs();
872 set_fs(KERNEL_DS);
873 host_err = vfs_readv(file, (struct iovec __user *)vec, vlen, &offset, 0);
874 set_fs(oldfs);
875 return nfsd_finish_read(file, count, host_err);
876}
877
878static __be32
879nfsd_vfs_read(struct svc_rqst *rqstp, struct file *file,
880 loff_t offset, struct kvec *vec, int vlen, unsigned long *count)
881{
882 if (file->f_op->splice_read && test_bit(RQ_SPLICE_OK, &rqstp->rq_flags))
883 return nfsd_splice_read(rqstp, file, offset, count);
884 else
885 return nfsd_readv(file, offset, vec, vlen, count);
886}
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902static int wait_for_concurrent_writes(struct file *file)
903{
904 struct inode *inode = file_inode(file);
905 static ino_t last_ino;
906 static dev_t last_dev;
907 int err = 0;
908
909 if (atomic_read(&inode->i_writecount) > 1
910 || (last_ino == inode->i_ino && last_dev == inode->i_sb->s_dev)) {
911 dprintk("nfsd: write defer %d\n", task_pid_nr(current));
912 msleep(10);
913 dprintk("nfsd: write resume %d\n", task_pid_nr(current));
914 }
915
916 if (inode->i_state & I_DIRTY) {
917 dprintk("nfsd: write sync %d\n", task_pid_nr(current));
918 err = vfs_fsync(file, 0);
919 }
920 last_ino = inode->i_ino;
921 last_dev = inode->i_sb->s_dev;
922 return err;
923}
924
925__be32
926nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
927 loff_t offset, struct kvec *vec, int vlen,
928 unsigned long *cnt, int *stablep)
929{
930 struct svc_export *exp;
931 struct inode *inode;
932 mm_segment_t oldfs;
933 __be32 err = 0;
934 int host_err;
935 int stable = *stablep;
936 int use_wgather;
937 loff_t pos = offset;
938 loff_t end = LLONG_MAX;
939 unsigned int pflags = current->flags;
940
941 if (test_bit(RQ_LOCAL, &rqstp->rq_flags))
942
943
944
945
946
947
948 current->flags |= PF_LESS_THROTTLE;
949
950 inode = file_inode(file);
951 exp = fhp->fh_export;
952
953 use_wgather = (rqstp->rq_vers == 2) && EX_WGATHER(exp);
954
955 if (!EX_ISSYNC(exp))
956 stable = 0;
957
958
959 oldfs = get_fs(); set_fs(KERNEL_DS);
960 host_err = vfs_writev(file, (struct iovec __user *)vec, vlen, &pos, 0);
961 set_fs(oldfs);
962 if (host_err < 0)
963 goto out_nfserr;
964 *cnt = host_err;
965 nfsdstats.io_write += host_err;
966 fsnotify_modify(file);
967
968 if (stable) {
969 if (use_wgather) {
970 host_err = wait_for_concurrent_writes(file);
971 } else {
972 if (*cnt)
973 end = offset + *cnt - 1;
974 host_err = vfs_fsync_range(file, offset, end, 0);
975 }
976 }
977
978out_nfserr:
979 dprintk("nfsd: write complete host_err=%d\n", host_err);
980 if (host_err >= 0)
981 err = 0;
982 else
983 err = nfserrno(host_err);
984 if (test_bit(RQ_LOCAL, &rqstp->rq_flags))
985 tsk_restore_flags(current, pflags, PF_LESS_THROTTLE);
986 return err;
987}
988
989
990
991
992
993
994__be32 nfsd_read(struct svc_rqst *rqstp, struct svc_fh *fhp,
995 loff_t offset, struct kvec *vec, int vlen, unsigned long *count)
996{
997 struct file *file;
998 struct raparms *ra;
999 __be32 err;
1000
1001 trace_read_start(rqstp, fhp, offset, vlen);
1002 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
1003 if (err)
1004 return err;
1005
1006 ra = nfsd_init_raparms(file);
1007
1008 trace_read_opened(rqstp, fhp, offset, vlen);
1009 err = nfsd_vfs_read(rqstp, file, offset, vec, vlen, count);
1010 trace_read_io_done(rqstp, fhp, offset, vlen);
1011
1012 if (ra)
1013 nfsd_put_raparams(file, ra);
1014 fput(file);
1015
1016 trace_read_done(rqstp, fhp, offset, vlen);
1017
1018 return err;
1019}
1020
1021
1022
1023
1024
1025
1026__be32
1027nfsd_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
1028 loff_t offset, struct kvec *vec, int vlen, unsigned long *cnt,
1029 int *stablep)
1030{
1031 __be32 err = 0;
1032
1033 trace_write_start(rqstp, fhp, offset, vlen);
1034
1035 if (file) {
1036 err = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry,
1037 NFSD_MAY_WRITE|NFSD_MAY_OWNER_OVERRIDE);
1038 if (err)
1039 goto out;
1040 trace_write_opened(rqstp, fhp, offset, vlen);
1041 err = nfsd_vfs_write(rqstp, fhp, file, offset, vec, vlen, cnt,
1042 stablep);
1043 trace_write_io_done(rqstp, fhp, offset, vlen);
1044 } else {
1045 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_WRITE, &file);
1046 if (err)
1047 goto out;
1048
1049 trace_write_opened(rqstp, fhp, offset, vlen);
1050 if (cnt)
1051 err = nfsd_vfs_write(rqstp, fhp, file, offset, vec, vlen,
1052 cnt, stablep);
1053 trace_write_io_done(rqstp, fhp, offset, vlen);
1054 fput(file);
1055 }
1056out:
1057 trace_write_done(rqstp, fhp, offset, vlen);
1058 return err;
1059}
1060
1061#ifdef CONFIG_NFSD_V3
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071__be32
1072nfsd_commit(struct svc_rqst *rqstp, struct svc_fh *fhp,
1073 loff_t offset, unsigned long count)
1074{
1075 struct file *file;
1076 loff_t end = LLONG_MAX;
1077 __be32 err = nfserr_inval;
1078
1079 if (offset < 0)
1080 goto out;
1081 if (count != 0) {
1082 end = offset + (loff_t)count - 1;
1083 if (end < offset)
1084 goto out;
1085 }
1086
1087 err = nfsd_open(rqstp, fhp, S_IFREG,
1088 NFSD_MAY_WRITE|NFSD_MAY_NOT_BREAK_LEASE, &file);
1089 if (err)
1090 goto out;
1091 if (EX_ISSYNC(fhp->fh_export)) {
1092 int err2 = vfs_fsync_range(file, offset, end, 0);
1093
1094 if (err2 != -EINVAL)
1095 err = nfserrno(err2);
1096 else
1097 err = nfserr_notsupp;
1098 }
1099
1100 fput(file);
1101out:
1102 return err;
1103}
1104#endif
1105
1106static __be32
1107nfsd_create_setattr(struct svc_rqst *rqstp, struct svc_fh *resfhp,
1108 struct iattr *iap)
1109{
1110
1111
1112
1113 iap->ia_valid &= ~ATTR_MODE;
1114
1115
1116
1117
1118
1119 if (!uid_eq(current_fsuid(), GLOBAL_ROOT_UID))
1120 iap->ia_valid &= ~(ATTR_UID|ATTR_GID);
1121 if (iap->ia_valid)
1122 return nfsd_setattr(rqstp, resfhp, iap, 0, (time_t)0);
1123
1124 return nfserrno(commit_metadata(resfhp));
1125}
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135static void
1136nfsd_check_ignore_resizing(struct iattr *iap)
1137{
1138 if ((iap->ia_valid & ATTR_SIZE) && (iap->ia_size == 0))
1139 iap->ia_valid &= ~ATTR_SIZE;
1140}
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150__be32
1151nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
1152 char *fname, int flen, struct iattr *iap,
1153 int type, dev_t rdev, struct svc_fh *resfhp)
1154{
1155 struct dentry *dentry, *dchild = NULL;
1156 struct inode *dirp;
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 = d_inode(dentry);
1174
1175 err = nfserr_notdir;
1176 if (!dirp->i_op->lookup)
1177 goto out;
1178
1179
1180
1181
1182 if (!resfhp->fh_dentry) {
1183 host_err = fh_want_write(fhp);
1184 if (host_err)
1185 goto out_nfserr;
1186
1187
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
1198 dchild = dget(resfhp->fh_dentry);
1199 if (!fhp->fh_locked) {
1200
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
1210
1211 err = nfserr_exist;
1212 if (d_really_is_positive(dchild)) {
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
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
1257
1258
1259
1260
1261 err2 = nfserrno(commit_metadata(fhp));
1262 if (err2)
1263 err = err2;
1264
1265
1266
1267 if (!err)
1268 err = fh_update(resfhp);
1269out:
1270 if (dchild && !IS_ERR(dchild))
1271 dput(dchild);
1272 return err;
1273
1274out_nfserr:
1275 err = nfserrno(host_err);
1276 goto out;
1277}
1278
1279#ifdef CONFIG_NFSD_V3
1280
1281
1282
1283
1284__be32
1285do_nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
1286 char *fname, int flen, struct iattr *iap,
1287 struct svc_fh *resfhp, int createmode, u32 *verifier,
1288 bool *truncp, bool *created)
1289{
1290 struct dentry *dentry, *dchild = NULL;
1291 struct inode *dirp;
1292 __be32 err;
1293 int host_err;
1294 __u32 v_mtime=0, v_atime=0;
1295
1296 err = nfserr_perm;
1297 if (!flen)
1298 goto out;
1299 err = nfserr_exist;
1300 if (isdotent(fname, flen))
1301 goto out;
1302 if (!(iap->ia_valid & ATTR_MODE))
1303 iap->ia_mode = 0;
1304 err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_EXEC);
1305 if (err)
1306 goto out;
1307
1308 dentry = fhp->fh_dentry;
1309 dirp = d_inode(dentry);
1310
1311
1312
1313 err = nfserr_notdir;
1314 if (!dirp->i_op->lookup)
1315 goto out;
1316
1317 host_err = fh_want_write(fhp);
1318 if (host_err)
1319 goto out_nfserr;
1320
1321 fh_lock_nested(fhp, I_MUTEX_PARENT);
1322
1323
1324
1325
1326 dchild = lookup_one_len(fname, dentry, flen);
1327 host_err = PTR_ERR(dchild);
1328 if (IS_ERR(dchild))
1329 goto out_nfserr;
1330
1331
1332 if (d_really_is_negative(dchild)) {
1333 err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE);
1334 if (err)
1335 goto out;
1336 }
1337
1338 err = fh_compose(resfhp, fhp->fh_export, dchild, fhp);
1339 if (err)
1340 goto out;
1341
1342 if (nfsd_create_is_exclusive(createmode)) {
1343
1344
1345
1346
1347
1348
1349 v_mtime = verifier[0]&0x7fffffff;
1350 v_atime = verifier[1]&0x7fffffff;
1351 }
1352
1353 if (d_really_is_positive(dchild)) {
1354 err = 0;
1355
1356 switch (createmode) {
1357 case NFS3_CREATE_UNCHECKED:
1358 if (! d_is_reg(dchild))
1359 goto out;
1360 else if (truncp) {
1361
1362
1363
1364
1365
1366
1367
1368 *truncp = (iap->ia_valid & ATTR_SIZE) && !iap->ia_size;
1369 }
1370 else {
1371 iap->ia_valid &= ATTR_SIZE;
1372 goto set_attr;
1373 }
1374 break;
1375 case NFS3_CREATE_EXCLUSIVE:
1376 if ( d_inode(dchild)->i_mtime.tv_sec == v_mtime
1377 && d_inode(dchild)->i_atime.tv_sec == v_atime
1378 && d_inode(dchild)->i_size == 0 ) {
1379 if (created)
1380 *created = 1;
1381 break;
1382 }
1383 case NFS4_CREATE_EXCLUSIVE4_1:
1384 if ( d_inode(dchild)->i_mtime.tv_sec == v_mtime
1385 && d_inode(dchild)->i_atime.tv_sec == v_atime
1386 && d_inode(dchild)->i_size == 0 ) {
1387 if (created)
1388 *created = 1;
1389 goto set_attr;
1390 }
1391
1392 case NFS3_CREATE_GUARDED:
1393 err = nfserr_exist;
1394 }
1395 fh_drop_write(fhp);
1396 goto out;
1397 }
1398
1399 host_err = vfs_create(dirp, dchild, iap->ia_mode, true);
1400 if (host_err < 0) {
1401 fh_drop_write(fhp);
1402 goto out_nfserr;
1403 }
1404 if (created)
1405 *created = 1;
1406
1407 nfsd_check_ignore_resizing(iap);
1408
1409 if (nfsd_create_is_exclusive(createmode)) {
1410
1411 iap->ia_valid = ATTR_MTIME|ATTR_ATIME
1412 | ATTR_MTIME_SET|ATTR_ATIME_SET;
1413
1414 iap->ia_mtime.tv_sec = v_mtime;
1415 iap->ia_atime.tv_sec = v_atime;
1416 iap->ia_mtime.tv_nsec = 0;
1417 iap->ia_atime.tv_nsec = 0;
1418 }
1419
1420 set_attr:
1421 err = nfsd_create_setattr(rqstp, resfhp, iap);
1422
1423
1424
1425
1426
1427 if (!err)
1428 err = nfserrno(commit_metadata(fhp));
1429
1430
1431
1432
1433 if (!err)
1434 err = fh_update(resfhp);
1435
1436 out:
1437 fh_unlock(fhp);
1438 if (dchild && !IS_ERR(dchild))
1439 dput(dchild);
1440 fh_drop_write(fhp);
1441 return err;
1442
1443 out_nfserr:
1444 err = nfserrno(host_err);
1445 goto out;
1446}
1447#endif
1448
1449
1450
1451
1452
1453
1454__be32
1455nfsd_readlink(struct svc_rqst *rqstp, struct svc_fh *fhp, char *buf, int *lenp)
1456{
1457 struct inode *inode;
1458 mm_segment_t oldfs;
1459 __be32 err;
1460 int host_err;
1461 struct path path;
1462
1463 err = fh_verify(rqstp, fhp, S_IFLNK, NFSD_MAY_NOP);
1464 if (err)
1465 goto out;
1466
1467 path.mnt = fhp->fh_export->ex_path.mnt;
1468 path.dentry = fhp->fh_dentry;
1469 inode = d_inode(path.dentry);
1470
1471 err = nfserr_inval;
1472 if (!inode->i_op->readlink)
1473 goto out;
1474
1475 touch_atime(&path);
1476
1477
1478
1479
1480 oldfs = get_fs(); set_fs(KERNEL_DS);
1481 host_err = inode->i_op->readlink(path.dentry, (char __user *)buf, *lenp);
1482 set_fs(oldfs);
1483
1484 if (host_err < 0)
1485 goto out_nfserr;
1486 *lenp = host_err;
1487 err = 0;
1488out:
1489 return err;
1490
1491out_nfserr:
1492 err = nfserrno(host_err);
1493 goto out;
1494}
1495
1496
1497
1498
1499
1500__be32
1501nfsd_symlink(struct svc_rqst *rqstp, struct svc_fh *fhp,
1502 char *fname, int flen,
1503 char *path,
1504 struct svc_fh *resfhp)
1505{
1506 struct dentry *dentry, *dnew;
1507 __be32 err, cerr;
1508 int host_err;
1509
1510 err = nfserr_noent;
1511 if (!flen || path[0] == '\0')
1512 goto out;
1513 err = nfserr_exist;
1514 if (isdotent(fname, flen))
1515 goto out;
1516
1517 err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE);
1518 if (err)
1519 goto out;
1520
1521 host_err = fh_want_write(fhp);
1522 if (host_err)
1523 goto out_nfserr;
1524
1525 fh_lock(fhp);
1526 dentry = fhp->fh_dentry;
1527 dnew = lookup_one_len(fname, dentry, flen);
1528 host_err = PTR_ERR(dnew);
1529 if (IS_ERR(dnew))
1530 goto out_nfserr;
1531
1532 host_err = vfs_symlink(d_inode(dentry), dnew, path);
1533 err = nfserrno(host_err);
1534 if (!err)
1535 err = nfserrno(commit_metadata(fhp));
1536 fh_unlock(fhp);
1537
1538 fh_drop_write(fhp);
1539
1540 cerr = fh_compose(resfhp, fhp->fh_export, dnew, fhp);
1541 dput(dnew);
1542 if (err==0) err = cerr;
1543out:
1544 return err;
1545
1546out_nfserr:
1547 err = nfserrno(host_err);
1548 goto out;
1549}
1550
1551
1552
1553
1554
1555__be32
1556nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,
1557 char *name, int len, struct svc_fh *tfhp)
1558{
1559 struct dentry *ddir, *dnew, *dold;
1560 struct inode *dirp;
1561 __be32 err;
1562 int host_err;
1563
1564 err = fh_verify(rqstp, ffhp, S_IFDIR, NFSD_MAY_CREATE);
1565 if (err)
1566 goto out;
1567 err = fh_verify(rqstp, tfhp, 0, NFSD_MAY_NOP);
1568 if (err)
1569 goto out;
1570 err = nfserr_isdir;
1571 if (d_is_dir(tfhp->fh_dentry))
1572 goto out;
1573 err = nfserr_perm;
1574 if (!len)
1575 goto out;
1576 err = nfserr_exist;
1577 if (isdotent(name, len))
1578 goto out;
1579
1580 host_err = fh_want_write(tfhp);
1581 if (host_err) {
1582 err = nfserrno(host_err);
1583 goto out;
1584 }
1585
1586 fh_lock_nested(ffhp, I_MUTEX_PARENT);
1587 ddir = ffhp->fh_dentry;
1588 dirp = d_inode(ddir);
1589
1590 dnew = lookup_one_len(name, ddir, len);
1591 host_err = PTR_ERR(dnew);
1592 if (IS_ERR(dnew))
1593 goto out_nfserr;
1594
1595 dold = tfhp->fh_dentry;
1596
1597 err = nfserr_noent;
1598 if (d_really_is_negative(dold))
1599 goto out_dput;
1600 host_err = vfs_link(dold, dirp, dnew, NULL);
1601 if (!host_err) {
1602 err = nfserrno(commit_metadata(ffhp));
1603 if (!err)
1604 err = nfserrno(commit_metadata(tfhp));
1605 } else {
1606 if (host_err == -EXDEV && rqstp->rq_vers == 2)
1607 err = nfserr_acces;
1608 else
1609 err = nfserrno(host_err);
1610 }
1611out_dput:
1612 dput(dnew);
1613out_unlock:
1614 fh_unlock(ffhp);
1615 fh_drop_write(tfhp);
1616out:
1617 return err;
1618
1619out_nfserr:
1620 err = nfserrno(host_err);
1621 goto out_unlock;
1622}
1623
1624
1625
1626
1627
1628__be32
1629nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen,
1630 struct svc_fh *tfhp, char *tname, int tlen)
1631{
1632 struct dentry *fdentry, *tdentry, *odentry, *ndentry, *trap;
1633 struct inode *fdir, *tdir;
1634 __be32 err;
1635 int host_err;
1636
1637 err = fh_verify(rqstp, ffhp, S_IFDIR, NFSD_MAY_REMOVE);
1638 if (err)
1639 goto out;
1640 err = fh_verify(rqstp, tfhp, S_IFDIR, NFSD_MAY_CREATE);
1641 if (err)
1642 goto out;
1643
1644 fdentry = ffhp->fh_dentry;
1645 fdir = d_inode(fdentry);
1646
1647 tdentry = tfhp->fh_dentry;
1648 tdir = d_inode(tdentry);
1649
1650 err = nfserr_perm;
1651 if (!flen || isdotent(fname, flen) || !tlen || isdotent(tname, tlen))
1652 goto out;
1653
1654 host_err = fh_want_write(ffhp);
1655 if (host_err) {
1656 err = nfserrno(host_err);
1657 goto out;
1658 }
1659
1660
1661
1662 trap = lock_rename(tdentry, fdentry);
1663 ffhp->fh_locked = tfhp->fh_locked = true;
1664 fill_pre_wcc(ffhp);
1665 fill_pre_wcc(tfhp);
1666
1667 odentry = lookup_one_len(fname, fdentry, flen);
1668 host_err = PTR_ERR(odentry);
1669 if (IS_ERR(odentry))
1670 goto out_nfserr;
1671
1672 host_err = -ENOENT;
1673 if (d_really_is_negative(odentry))
1674 goto out_dput_old;
1675 host_err = -EINVAL;
1676 if (odentry == trap)
1677 goto out_dput_old;
1678
1679 ndentry = lookup_one_len(tname, tdentry, tlen);
1680 host_err = PTR_ERR(ndentry);
1681 if (IS_ERR(ndentry))
1682 goto out_dput_old;
1683 host_err = -ENOTEMPTY;
1684 if (ndentry == trap)
1685 goto out_dput_new;
1686
1687 host_err = -EXDEV;
1688 if (ffhp->fh_export->ex_path.mnt != tfhp->fh_export->ex_path.mnt)
1689 goto out_dput_new;
1690 if (ffhp->fh_export->ex_path.dentry != tfhp->fh_export->ex_path.dentry)
1691 goto out_dput_new;
1692
1693 host_err = vfs_rename(fdir, odentry, tdir, ndentry, NULL, 0);
1694 if (!host_err) {
1695 host_err = commit_metadata(tfhp);
1696 if (!host_err)
1697 host_err = commit_metadata(ffhp);
1698 }
1699 out_dput_new:
1700 dput(ndentry);
1701 out_dput_old:
1702 dput(odentry);
1703 out_nfserr:
1704 err = nfserrno(host_err);
1705
1706
1707
1708
1709
1710 fill_post_wcc(ffhp);
1711 fill_post_wcc(tfhp);
1712 unlock_rename(tdentry, fdentry);
1713 ffhp->fh_locked = tfhp->fh_locked = false;
1714 fh_drop_write(ffhp);
1715
1716out:
1717 return err;
1718}
1719
1720
1721
1722
1723
1724__be32
1725nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
1726 char *fname, int flen)
1727{
1728 struct dentry *dentry, *rdentry;
1729 struct inode *dirp;
1730 __be32 err;
1731 int host_err;
1732
1733 err = nfserr_acces;
1734 if (!flen || isdotent(fname, flen))
1735 goto out;
1736 err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_REMOVE);
1737 if (err)
1738 goto out;
1739
1740 host_err = fh_want_write(fhp);
1741 if (host_err)
1742 goto out_nfserr;
1743
1744 fh_lock_nested(fhp, I_MUTEX_PARENT);
1745 dentry = fhp->fh_dentry;
1746 dirp = d_inode(dentry);
1747
1748 rdentry = lookup_one_len(fname, dentry, flen);
1749 host_err = PTR_ERR(rdentry);
1750 if (IS_ERR(rdentry))
1751 goto out_nfserr;
1752
1753 if (d_really_is_negative(rdentry)) {
1754 dput(rdentry);
1755 err = nfserr_noent;
1756 goto out;
1757 }
1758
1759 if (!type)
1760 type = d_inode(rdentry)->i_mode & S_IFMT;
1761
1762 if (type != S_IFDIR)
1763 host_err = vfs_unlink(dirp, rdentry, NULL);
1764 else
1765 host_err = vfs_rmdir(dirp, rdentry);
1766 if (!host_err)
1767 host_err = commit_metadata(fhp);
1768 dput(rdentry);
1769
1770out_nfserr:
1771 err = nfserrno(host_err);
1772out:
1773 return err;
1774}
1775
1776
1777
1778
1779
1780
1781
1782
1783struct buffered_dirent {
1784 u64 ino;
1785 loff_t offset;
1786 int namlen;
1787 unsigned int d_type;
1788 char name[];
1789};
1790
1791struct readdir_data {
1792 struct dir_context ctx;
1793 char *dirent;
1794 size_t used;
1795 int full;
1796};
1797
1798static int nfsd_buffered_filldir(struct dir_context *ctx, const char *name,
1799 int namlen, loff_t offset, u64 ino,
1800 unsigned int d_type)
1801{
1802 struct readdir_data *buf =
1803 container_of(ctx, struct readdir_data, ctx);
1804 struct buffered_dirent *de = (void *)(buf->dirent + buf->used);
1805 unsigned int reclen;
1806
1807 reclen = ALIGN(sizeof(struct buffered_dirent) + namlen, sizeof(u64));
1808 if (buf->used + reclen > PAGE_SIZE) {
1809 buf->full = 1;
1810 return -EINVAL;
1811 }
1812
1813 de->namlen = namlen;
1814 de->offset = offset;
1815 de->ino = ino;
1816 de->d_type = d_type;
1817 memcpy(de->name, name, namlen);
1818 buf->used += reclen;
1819
1820 return 0;
1821}
1822
1823static __be32 nfsd_buffered_readdir(struct file *file, nfsd_filldir_t func,
1824 struct readdir_cd *cdp, loff_t *offsetp)
1825{
1826 struct buffered_dirent *de;
1827 int host_err;
1828 int size;
1829 loff_t offset;
1830 struct readdir_data buf = {
1831 .ctx.actor = nfsd_buffered_filldir,
1832 .dirent = (void *)__get_free_page(GFP_KERNEL)
1833 };
1834
1835 if (!buf.dirent)
1836 return nfserrno(-ENOMEM);
1837
1838 offset = *offsetp;
1839
1840 while (1) {
1841 unsigned int reclen;
1842
1843 cdp->err = nfserr_eof;
1844 buf.used = 0;
1845 buf.full = 0;
1846
1847 host_err = iterate_dir(file, &buf.ctx);
1848 if (buf.full)
1849 host_err = 0;
1850
1851 if (host_err < 0)
1852 break;
1853
1854 size = buf.used;
1855
1856 if (!size)
1857 break;
1858
1859 de = (struct buffered_dirent *)buf.dirent;
1860 while (size > 0) {
1861 offset = de->offset;
1862
1863 if (func(cdp, de->name, de->namlen, de->offset,
1864 de->ino, de->d_type))
1865 break;
1866
1867 if (cdp->err != nfs_ok)
1868 break;
1869
1870 reclen = ALIGN(sizeof(*de) + de->namlen,
1871 sizeof(u64));
1872 size -= reclen;
1873 de = (struct buffered_dirent *)((char *)de + reclen);
1874 }
1875 if (size > 0)
1876 break;
1877
1878 offset = vfs_llseek(file, 0, SEEK_CUR);
1879 }
1880
1881 free_page((unsigned long)(buf.dirent));
1882
1883 if (host_err)
1884 return nfserrno(host_err);
1885
1886 *offsetp = offset;
1887 return cdp->err;
1888}
1889
1890
1891
1892
1893
1894__be32
1895nfsd_readdir(struct svc_rqst *rqstp, struct svc_fh *fhp, loff_t *offsetp,
1896 struct readdir_cd *cdp, nfsd_filldir_t func)
1897{
1898 __be32 err;
1899 struct file *file;
1900 loff_t offset = *offsetp;
1901 int may_flags = NFSD_MAY_READ;
1902
1903
1904 if (rqstp->rq_vers > 2)
1905 may_flags |= NFSD_MAY_64BIT_COOKIE;
1906
1907 err = nfsd_open(rqstp, fhp, S_IFDIR, may_flags, &file);
1908 if (err)
1909 goto out;
1910
1911 offset = vfs_llseek(file, offset, SEEK_SET);
1912 if (offset < 0) {
1913 err = nfserrno((int)offset);
1914 goto out_close;
1915 }
1916
1917 err = nfsd_buffered_readdir(file, func, cdp, offsetp);
1918
1919 if (err == nfserr_eof || err == nfserr_toosmall)
1920 err = nfs_ok;
1921out_close:
1922 fput(file);
1923out:
1924 return err;
1925}
1926
1927
1928
1929
1930
1931__be32
1932nfsd_statfs(struct svc_rqst *rqstp, struct svc_fh *fhp, struct kstatfs *stat, int access)
1933{
1934 __be32 err;
1935
1936 err = fh_verify(rqstp, fhp, 0, NFSD_MAY_NOP | access);
1937 if (!err) {
1938 struct path path = {
1939 .mnt = fhp->fh_export->ex_path.mnt,
1940 .dentry = fhp->fh_dentry,
1941 };
1942 if (vfs_statfs(&path, stat))
1943 err = nfserr_io;
1944 }
1945 return err;
1946}
1947
1948static int exp_rdonly(struct svc_rqst *rqstp, struct svc_export *exp)
1949{
1950 return nfsexp_flags(rqstp, exp) & NFSEXP_READONLY;
1951}
1952
1953
1954
1955
1956__be32
1957nfsd_permission(struct svc_rqst *rqstp, struct svc_export *exp,
1958 struct dentry *dentry, int acc)
1959{
1960 struct inode *inode = d_inode(dentry);
1961 int err;
1962
1963 if ((acc & NFSD_MAY_MASK) == NFSD_MAY_NOP)
1964 return 0;
1965#if 0
1966 dprintk("nfsd: permission 0x%x%s%s%s%s%s%s%s mode 0%o%s%s%s\n",
1967 acc,
1968 (acc & NFSD_MAY_READ)? " read" : "",
1969 (acc & NFSD_MAY_WRITE)? " write" : "",
1970 (acc & NFSD_MAY_EXEC)? " exec" : "",
1971 (acc & NFSD_MAY_SATTR)? " sattr" : "",
1972 (acc & NFSD_MAY_TRUNC)? " trunc" : "",
1973 (acc & NFSD_MAY_LOCK)? " lock" : "",
1974 (acc & NFSD_MAY_OWNER_OVERRIDE)? " owneroverride" : "",
1975 inode->i_mode,
1976 IS_IMMUTABLE(inode)? " immut" : "",
1977 IS_APPEND(inode)? " append" : "",
1978 __mnt_is_readonly(exp->ex_path.mnt)? " ro" : "");
1979 dprintk(" owner %d/%d user %d/%d\n",
1980 inode->i_uid, inode->i_gid, current_fsuid(), current_fsgid());
1981#endif
1982
1983
1984
1985
1986
1987 if (!(acc & NFSD_MAY_LOCAL_ACCESS))
1988 if (acc & (NFSD_MAY_WRITE | NFSD_MAY_SATTR | NFSD_MAY_TRUNC)) {
1989 if (exp_rdonly(rqstp, exp) ||
1990 __mnt_is_readonly(exp->ex_path.mnt))
1991 return nfserr_rofs;
1992 if ( IS_IMMUTABLE(inode))
1993 return nfserr_perm;
1994 }
1995 if ((acc & NFSD_MAY_TRUNC) && IS_APPEND(inode))
1996 return nfserr_perm;
1997
1998 if (acc & NFSD_MAY_LOCK) {
1999
2000
2001
2002
2003 if (exp->ex_flags & NFSEXP_NOAUTHNLM)
2004 return 0;
2005 else
2006 acc = NFSD_MAY_READ | NFSD_MAY_OWNER_OVERRIDE;
2007 }
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022 if ((acc & NFSD_MAY_OWNER_OVERRIDE) &&
2023 uid_eq(inode->i_uid, current_fsuid()))
2024 return 0;
2025
2026
2027 err = inode_permission(inode, acc & (MAY_READ|MAY_WRITE|MAY_EXEC));
2028
2029
2030 if (err == -EACCES && S_ISREG(inode->i_mode) &&
2031 (acc == (NFSD_MAY_READ | NFSD_MAY_OWNER_OVERRIDE) ||
2032 acc == (NFSD_MAY_READ | NFSD_MAY_READ_IF_EXEC)))
2033 err = inode_permission(inode, MAY_EXEC);
2034
2035 return err? nfserrno(err) : 0;
2036}
2037
2038void
2039nfsd_racache_shutdown(void)
2040{
2041 struct raparms *raparm, *last_raparm;
2042 unsigned int i;
2043
2044 dprintk("nfsd: freeing readahead buffers.\n");
2045
2046 for (i = 0; i < RAPARM_HASH_SIZE; i++) {
2047 raparm = raparm_hash[i].pb_head;
2048 while(raparm) {
2049 last_raparm = raparm;
2050 raparm = raparm->p_next;
2051 kfree(last_raparm);
2052 }
2053 raparm_hash[i].pb_head = NULL;
2054 }
2055}
2056
2057
2058
2059int
2060nfsd_racache_init(int cache_size)
2061{
2062 int i;
2063 int j = 0;
2064 int nperbucket;
2065 struct raparms **raparm = NULL;
2066
2067
2068 if (raparm_hash[0].pb_head)
2069 return 0;
2070 nperbucket = DIV_ROUND_UP(cache_size, RAPARM_HASH_SIZE);
2071 nperbucket = max(2, nperbucket);
2072 cache_size = nperbucket * RAPARM_HASH_SIZE;
2073
2074 dprintk("nfsd: allocating %d readahead buffers.\n", cache_size);
2075
2076 for (i = 0; i < RAPARM_HASH_SIZE; i++) {
2077 spin_lock_init(&raparm_hash[i].pb_lock);
2078
2079 raparm = &raparm_hash[i].pb_head;
2080 for (j = 0; j < nperbucket; j++) {
2081 *raparm = kzalloc(sizeof(struct raparms), GFP_KERNEL);
2082 if (!*raparm)
2083 goto out_nomem;
2084 raparm = &(*raparm)->p_next;
2085 }
2086 *raparm = NULL;
2087 }
2088
2089 nfsdstats.ra_size = cache_size;
2090 return 0;
2091
2092out_nomem:
2093 dprintk("nfsd: kmalloc failed, freeing readahead buffers\n");
2094 nfsd_racache_shutdown();
2095 return -ENOMEM;
2096}
2097