v2.4.9.9 -> v2.4.9.10
[opensuse:kernel.git] / fs / nfsd / vfs.c
1 #define MSNFS   /* HACK HACK */
2 /*
3  * linux/fs/nfsd/vfs.c
4  *
5  * File operations used by nfsd. Some of these have been ripped from
6  * other parts of the kernel because they weren't in ksyms.c, others
7  * are partial duplicates with added or changed functionality.
8  *
9  * Note that several functions dget() the dentry upon which they want
10  * to act, most notably those that create directory entries. Response
11  * dentry's are dput()'d if necessary in the release callback.
12  * So if you notice code paths that apparently fail to dput() the
13  * dentry, don't worry--they have been taken care of.
14  *
15  * Copyright (C) 1995-1999 Olaf Kirch <okir@monad.swb.de>
16  */
17
18 #include <linux/config.h>
19 #include <linux/version.h>
20 #include <linux/string.h>
21 #include <linux/sched.h>
22 #include <linux/errno.h>
23 #include <linux/locks.h>
24 #include <linux/fs.h>
25 #include <linux/major.h>
26 #include <linux/ext2_fs.h>
27 #include <linux/proc_fs.h>
28 #include <linux/stat.h>
29 #include <linux/fcntl.h>
30 #include <linux/net.h>
31 #include <linux/unistd.h>
32 #include <linux/slab.h>
33 #include <linux/in.h>
34 #define __NO_VERSION__
35 #include <linux/module.h>
36
37 #include <linux/sunrpc/svc.h>
38 #include <linux/nfsd/nfsd.h>
39 #ifdef CONFIG_NFSD_V3
40 #include <linux/nfs3.h>
41 #include <linux/nfsd/xdr3.h>
42 #endif /* CONFIG_NFSD_V3 */
43 #include <linux/nfsd/nfsfh.h>
44 #include <linux/quotaops.h>
45
46 #include <asm/uaccess.h>
47
48 #define NFSDDBG_FACILITY                NFSDDBG_FILEOP
49 #define NFSD_PARANOIA
50
51
52 /* We must ignore files (but only files) which might have mandatory
53  * locks on them because there is no way to know if the accesser has
54  * the lock.
55  */
56 #define IS_ISMNDLK(i)   (S_ISREG((i)->i_mode) && MANDATORY_LOCK(i))
57
58 /*
59  * This is a cache of readahead params that help us choose the proper
60  * readahead strategy. Initially, we set all readahead parameters to 0
61  * and let the VFS handle things.
62  * If you increase the number of cached files very much, you'll need to
63  * add a hash table here.
64  */
65 struct raparms {
66         struct raparms          *p_next;
67         unsigned int            p_count;
68         ino_t                   p_ino;
69         dev_t                   p_dev;
70         unsigned long           p_reada,
71                                 p_ramax,
72                                 p_raend,
73                                 p_ralen,
74                                 p_rawin;
75 };
76
77 static struct raparms *         raparml;
78 static struct raparms *         raparm_cache;
79
80 /*
81  * Look up one component of a pathname.
82  * N.B. After this call _both_ fhp and resfh need an fh_put
83  *
84  * If the lookup would cross a mountpoint, and the mounted filesystem
85  * is exported to the client with NFSEXP_CROSSMNT, then the lookup is
86  * accepted as it stands and the mounted directory is
87  * returned. Otherwise the covered directory is returned.
88  * NOTE: this mountpoint crossing is not supported properly by all
89  *   clients and is explicitly disallowed for NFSv3
90  *      NeilBrown <neilb@cse.unsw.edu.au>
91  */
92 int
93 nfsd_lookup(struct svc_rqst *rqstp, struct svc_fh *fhp, const char *name,
94                                         int len, struct svc_fh *resfh)
95 {
96         struct svc_export       *exp;
97         struct dentry           *dparent;
98         struct dentry           *dentry;
99         int                     err;
100
101         dprintk("nfsd: nfsd_lookup(fh %s, %*.*s)\n", SVCFH_fmt(fhp), len,len,name);
102
103         /* Obtain dentry and export. */
104         err = fh_verify(rqstp, fhp, S_IFDIR, MAY_EXEC);
105         if (err)
106                 goto out;
107
108         dparent = fhp->fh_dentry;
109         exp  = fhp->fh_export;
110
111         err = nfserr_acces;
112
113         /* Lookup the name, but don't follow links */
114         if (isdotent(name, len)) {
115                 if (len==1)
116                         dentry = dget(dparent);
117                 else  { /* must be ".." */
118                         /* checking mountpoint crossing is very different when stepping up */
119                         if (dparent == exp->ex_dentry) {
120                                 if (!EX_CROSSMNT(exp))
121                                         dentry = dget(dparent); /* .. == . just like at / */
122                                 else
123                                 {
124                                         struct svc_export *exp2 = NULL;
125                                         struct dentry *dp;
126                                         struct vfsmount *mnt = mntget(exp->ex_mnt);
127                                         dentry = dget(dparent);
128                                         while(follow_up(&mnt, &dentry))
129                                                 ;
130                                         dp = dget(dentry->d_parent);
131                                         dput(dentry);
132                                         dentry = dp;
133                                         for ( ; exp2 == NULL && dp->d_parent != dp;
134                                               dp=dp->d_parent)
135                                                 exp2 = exp_get(exp->ex_client, dp->d_inode->i_dev, dp->d_inode->i_ino);
136                                         if (exp2==NULL) {
137                                                 dput(dentry);
138                                                 dentry = dget(dparent);
139                                         } else {
140                                                 exp = exp2;
141                                         }
142                                         mntput(mnt);
143                                 }
144                         } else
145                                 dentry = dget(dparent->d_parent);
146                 }
147         } else {
148                 fh_lock(fhp);
149                 dentry = lookup_one_len(name, dparent, len);
150                 err = PTR_ERR(dentry);
151                 if (IS_ERR(dentry))
152                         goto out_nfserr;
153                 /*
154                  * check if we have crossed a mount point ...
155                  */
156                 if (d_mountpoint(dentry)) {
157                         struct svc_export *exp2 = NULL;
158                         struct vfsmount *mnt = mntget(exp->ex_mnt);
159                         struct dentry *mounts = dget(dentry);
160                         while (follow_down(&mnt,&mounts)&&d_mountpoint(mounts))
161                                 ;
162                         exp2 = exp_get(rqstp->rq_client,
163                                        mounts->d_inode->i_dev,
164                                        mounts->d_inode->i_ino);
165                         if (exp2 && EX_CROSSMNT(exp2)) {
166                                 /* successfully crossed mount point */
167                                 exp = exp2;
168                                 dput(dentry);
169                                 dentry = mounts;
170                         } else
171                                 dput(mounts);
172                         mntput(mnt);
173                 }
174         }
175         /*
176          * Note: we compose the file handle now, but as the
177          * dentry may be negative, it may need to be updated.
178          */
179         err = fh_compose(resfh, exp, dentry, fhp);
180         if (!err && !dentry->d_inode)
181                 err = nfserr_noent;
182 out:
183         return err;
184
185 out_nfserr:
186         err = nfserrno(err);
187         goto out;
188 }
189
190 /*
191  * Set various file attributes.
192  * N.B. After this call fhp needs an fh_put
193  */
194 int
195 nfsd_setattr(struct svc_rqst *rqstp, struct svc_fh *fhp, struct iattr *iap,
196              int check_guard, time_t guardtime)
197 {
198         struct dentry   *dentry;
199         struct inode    *inode;
200         int             accmode = MAY_SATTR;
201         int             ftype = 0;
202         int             imode;
203         int             err;
204         int             size_change = 0;
205
206         if (iap->ia_valid & (ATTR_ATIME | ATTR_MTIME | ATTR_SIZE))
207                 accmode |= MAY_WRITE|MAY_OWNER_OVERRIDE;
208         if (iap->ia_valid & ATTR_SIZE)
209                 ftype = S_IFREG;
210
211         /* Get inode */
212         err = fh_verify(rqstp, fhp, ftype, accmode);
213         if (err || !iap->ia_valid)
214                 goto out;
215
216         dentry = fhp->fh_dentry;
217         inode = dentry->d_inode;
218
219         err = inode_change_ok(inode, iap);
220         /* could be a "touch" (utimes) request where the user is not the owner but does
221          * have write permission. In this case the user should be allowed to set
222          * both times to the current time.  We could just assume any such SETATTR
223          * is intended to set the times to "now", but we do a couple of simple tests
224          * to increase our confidence.
225          */
226 #define BOTH_TIME_SET (ATTR_ATIME_SET | ATTR_MTIME_SET)
227 #define MAX_TOUCH_TIME_ERROR (30*60)
228         if (err
229             && (iap->ia_valid & BOTH_TIME_SET) == BOTH_TIME_SET
230             && iap->ia_mtime == iap->ia_ctime
231             ) {
232             /* looks good.  now just make sure time is in the right ballpark.
233              * solaris, at least, doesn't seem to care what the time request is
234              */
235             time_t delta = iap->ia_atime - CURRENT_TIME;
236             if (delta<0) delta = -delta;
237             if (delta < MAX_TOUCH_TIME_ERROR) {
238                 /* turn off ATTR_[AM]TIME_SET but leave ATTR_[AM]TIME
239                  * this will cause notify_change to set these times to "now"
240                  */
241                 iap->ia_valid &= ~BOTH_TIME_SET;
242                 err = inode_change_ok(inode, iap);
243             }
244         }
245             
246         if (err)
247                 goto out_nfserr;
248
249         /* The size case is special. It changes the file as well as the attributes.  */
250         if (iap->ia_valid & ATTR_SIZE) {
251                 if (iap->ia_size < inode->i_size) {
252                         err = nfsd_permission(fhp->fh_export, dentry, MAY_TRUNC|MAY_OWNER_OVERRIDE);
253                         if (err)
254                                 goto out;
255                 }
256
257                 /*
258                  * If we are changing the size of the file, then
259                  * we need to break all leases.
260                  */
261                 err = get_lease(inode, FMODE_WRITE);
262                 if (err)
263                         goto out_nfserr;
264
265                 err = get_write_access(inode);
266                 if (err)
267                         goto out_nfserr;
268
269                 err = locks_verify_truncate(inode, NULL, iap->ia_size);
270                 if (err) {
271                         put_write_access(inode);
272                         goto out_nfserr;
273                 }
274                 DQUOT_INIT(inode);
275         }
276
277         imode = inode->i_mode;
278         if (iap->ia_valid & ATTR_MODE) {
279                 iap->ia_mode &= S_IALLUGO;
280                 imode = iap->ia_mode |= (imode & ~S_IALLUGO);
281         }
282
283         /* Revoke setuid/setgid bit on chown/chgrp */
284         if ((iap->ia_valid & ATTR_UID) && (imode & S_ISUID)
285          && iap->ia_uid != inode->i_uid) {
286                 iap->ia_valid |= ATTR_MODE;
287                 iap->ia_mode = imode &= ~S_ISUID;
288         }
289         if ((iap->ia_valid & ATTR_GID) && (imode & S_ISGID)
290          && iap->ia_gid != inode->i_gid) {
291                 iap->ia_valid |= ATTR_MODE;
292                 iap->ia_mode = imode &= ~S_ISGID;
293         }
294
295         /* Change the attributes. */
296
297
298         iap->ia_valid |= ATTR_CTIME;
299 #ifdef CONFIG_QUOTA
300         /* DQUOT_TRANSFER needs both ia_uid and ia_gid defined */
301         if (iap->ia_valid & (ATTR_UID|ATTR_GID)) {
302                 if (! (iap->ia_valid & ATTR_UID))
303                         iap->ia_uid = inode->i_uid;
304                 if (! (iap->ia_valid & ATTR_GID))
305                         iap->ia_gid = inode->i_gid;
306                 iap->ia_valid |= ATTR_UID|ATTR_GID;
307         }
308 #endif /* CONFIG_QUOTA */
309
310         if (iap->ia_valid & ATTR_SIZE) {
311                 fh_lock(fhp);
312                 size_change = 1;
313         }
314         err = nfserr_notsync;
315         if (!check_guard || guardtime == inode->i_ctime) {
316 #ifdef CONFIG_QUOTA
317                 if (iap->ia_valid & (ATTR_UID|ATTR_GID)) 
318                         err = DQUOT_TRANSFER(dentry, iap);
319                 else
320 #endif
321                         err = notify_change(dentry, iap);
322                 err = nfserrno(err);
323         }
324         if (size_change) {
325                 fh_unlock(fhp);
326                 put_write_access(inode);
327         }
328         if (!err)
329                 if (EX_ISSYNC(fhp->fh_export))
330                         write_inode_now(inode, 1);
331 out:
332         return err;
333
334 out_nfserr:
335         err = nfserrno(err);
336         goto out;
337 }
338
339 #ifdef CONFIG_NFSD_V3
340 /*
341  * Check server access rights to a file system object
342  */
343 struct accessmap {
344         u32             access;
345         int             how;
346 };
347 static struct accessmap nfs3_regaccess[] = {
348     {   NFS3_ACCESS_READ,       MAY_READ                        },
349     {   NFS3_ACCESS_EXECUTE,    MAY_EXEC                        },
350     {   NFS3_ACCESS_MODIFY,     MAY_WRITE|MAY_TRUNC             },
351     {   NFS3_ACCESS_EXTEND,     MAY_WRITE                       },
352
353     {   0,                      0                               }
354 };
355
356 static struct accessmap nfs3_diraccess[] = {
357     {   NFS3_ACCESS_READ,       MAY_READ                        },
358     {   NFS3_ACCESS_LOOKUP,     MAY_EXEC                        },
359     {   NFS3_ACCESS_MODIFY,     MAY_EXEC|MAY_WRITE|MAY_TRUNC    },
360     {   NFS3_ACCESS_EXTEND,     MAY_EXEC|MAY_WRITE              },
361     {   NFS3_ACCESS_DELETE,     MAY_REMOVE                      },
362
363     {   0,                      0                               }
364 };
365
366 static struct accessmap nfs3_anyaccess[] = {
367         /* Some clients - Solaris 2.6 at least, make an access call
368          * to the server to check for access for things like /dev/null
369          * (which really, the server doesn't care about).  So
370          * We provide simple access checking for them, looking
371          * mainly at mode bits
372          */
373     {   NFS3_ACCESS_READ,       MAY_READ                        },
374     {   NFS3_ACCESS_EXECUTE,    MAY_EXEC                        },
375     {   NFS3_ACCESS_MODIFY,     MAY_WRITE                       },
376     {   NFS3_ACCESS_EXTEND,     MAY_WRITE                       },
377
378     {   0,                      0                               }
379 };
380
381 int
382 nfsd_access(struct svc_rqst *rqstp, struct svc_fh *fhp, u32 *access)
383 {
384         struct accessmap        *map;
385         struct svc_export       *export;
386         struct dentry           *dentry;
387         u32                     query, result = 0;
388         unsigned int            error;
389
390         error = fh_verify(rqstp, fhp, 0, MAY_NOP);
391         if (error)
392                 goto out;
393
394         export = fhp->fh_export;
395         dentry = fhp->fh_dentry;
396
397         if (S_ISREG(dentry->d_inode->i_mode))
398                 map = nfs3_regaccess;
399         else if (S_ISDIR(dentry->d_inode->i_mode))
400                 map = nfs3_diraccess;
401         else
402                 map = nfs3_anyaccess;
403
404
405         query = *access;
406         for  (; map->access; map++) {
407                 if (map->access & query) {
408                         unsigned int err2;
409                         err2 = nfsd_permission(export, dentry, map->how);
410                         switch (err2) {
411                         case nfs_ok:
412                                 result |= map->access;
413                                 break;
414                                 
415                         /* the following error codes just mean the access was not allowed,
416                          * rather than an error occurred */
417                         case nfserr_rofs:
418                         case nfserr_acces:
419                         case nfserr_perm:
420                                 /* simply don't "or" in the access bit. */
421                                 break;
422                         default:
423                                 error = err2;
424                                 goto out;
425                         }
426                 }
427         }
428         *access = result;
429
430  out:
431         return error;
432 }
433 #endif /* CONFIG_NFSD_V3 */
434
435
436
437 /*
438  * Open an existing file or directory.
439  * The access argument indicates the type of open (read/write/lock)
440  * N.B. After this call fhp needs an fh_put
441  */
442 int
443 nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
444                         int access, struct file *filp)
445 {
446         struct dentry   *dentry;
447         struct inode    *inode;
448         int             err;
449
450         /* If we get here, then the client has already done an "open", and (hopefully)
451          * checked permission - so allow OWNER_OVERRIDE in case a chmod has now revoked
452          * permission */
453         err = fh_verify(rqstp, fhp, type, access | MAY_OWNER_OVERRIDE);
454         if (err)
455                 goto out;
456
457         dentry = fhp->fh_dentry;
458         inode = dentry->d_inode;
459
460         /* Disallow access to files with the append-only bit set or
461          * with mandatory locking enabled
462          */
463         err = nfserr_perm;
464         if (IS_APPEND(inode) || IS_ISMNDLK(inode))
465                 goto out;
466         if (!inode->i_fop)
467                 goto out;
468
469         /*
470          * Check to see if there are any leases on this file.
471          * This may block while leases are broken.
472          */
473         err = get_lease(inode, (access & MAY_WRITE) ? FMODE_WRITE : 0);
474         if (err)
475                 goto out_nfserr;
476
477         if ((access & MAY_WRITE) && (err = get_write_access(inode)) != 0)
478                 goto out_nfserr;
479
480         memset(filp, 0, sizeof(*filp));
481         filp->f_op    = fops_get(inode->i_fop);
482         atomic_set(&filp->f_count, 1);
483         filp->f_dentry = dentry;
484         filp->f_vfsmnt = fhp->fh_export->ex_mnt;
485         if (access & MAY_WRITE) {
486                 filp->f_flags = O_WRONLY|O_LARGEFILE;
487                 filp->f_mode  = FMODE_WRITE;
488                 DQUOT_INIT(inode);
489         } else {
490                 filp->f_flags = O_RDONLY|O_LARGEFILE;
491                 filp->f_mode  = FMODE_READ;
492         }
493
494         err = 0;
495         if (filp->f_op && filp->f_op->open) {
496                 err = filp->f_op->open(inode, filp);
497                 if (err) {
498                         fops_put(filp->f_op);
499                         if (access & MAY_WRITE)
500                                 put_write_access(inode);
501
502                         /* I nearly added put_filp() call here, but this filp
503                          * is really on callers stack frame. -DaveM
504                          */
505                         atomic_dec(&filp->f_count);
506                 }
507         }
508 out_nfserr:
509         if (err)
510                 err = nfserrno(err);
511 out:
512         return err;
513 }
514
515 /*
516  * Close a file.
517  */
518 void
519 nfsd_close(struct file *filp)
520 {
521         struct dentry   *dentry = filp->f_dentry;
522         struct inode    *inode = dentry->d_inode;
523
524         if (filp->f_op && filp->f_op->release)
525                 filp->f_op->release(inode, filp);
526         fops_put(filp->f_op);
527         if (filp->f_mode & FMODE_WRITE)
528                 put_write_access(inode);
529 }
530
531 /*
532  * Sync a file
533  * As this calls fsync (not fdatasync) there is no need for a write_inode
534  * after it.
535  */
536 void
537 nfsd_sync(struct file *filp)
538 {
539         dprintk("nfsd: sync file %s\n", filp->f_dentry->d_name.name);
540         down(&filp->f_dentry->d_inode->i_sem);
541         filp->f_op->fsync(filp, filp->f_dentry, 0);
542         up(&filp->f_dentry->d_inode->i_sem);
543 }
544
545 void
546 nfsd_sync_dir(struct dentry *dp)
547 {
548         struct inode *inode = dp->d_inode;
549         int (*fsync) (struct file *, struct dentry *, int);
550         
551         if (inode->i_fop && (fsync = inode->i_fop->fsync)) {
552                 fsync(NULL, dp, 0);
553         }
554 }
555
556 /*
557  * Obtain the readahead parameters for the file
558  * specified by (dev, ino).
559  */
560 static inline struct raparms *
561 nfsd_get_raparms(dev_t dev, ino_t ino)
562 {
563         struct raparms  *ra, **rap, **frap = NULL;
564         int depth = 0;
565         
566         for (rap = &raparm_cache; (ra = *rap); rap = &ra->p_next) {
567                 if (ra->p_ino == ino && ra->p_dev == dev)
568                         goto found;
569                 depth++;
570                 if (ra->p_count == 0)
571                         frap = rap;
572         }
573         depth = nfsdstats.ra_size*11/10;
574         if (!frap)
575                 return NULL;
576         rap = frap;
577         ra = *frap;
578         memset(ra, 0, sizeof(*ra));
579         ra->p_dev = dev;
580         ra->p_ino = ino;
581 found:
582         if (rap != &raparm_cache) {
583                 *rap = ra->p_next;
584                 ra->p_next   = raparm_cache;
585                 raparm_cache = ra;
586         }
587         ra->p_count++;
588         nfsdstats.ra_depth[depth*10/nfsdstats.ra_size]++;
589         return ra;
590 }
591
592 /*
593  * Read data from a file. count must contain the requested read count
594  * on entry. On return, *count contains the number of bytes actually read.
595  * N.B. After this call fhp needs an fh_put
596  */
597 int
598 nfsd_read(struct svc_rqst *rqstp, struct svc_fh *fhp, loff_t offset,
599           char *buf, unsigned long *count)
600 {
601         struct raparms  *ra;
602         mm_segment_t    oldfs;
603         int             err;
604         struct file     file;
605
606         err = nfsd_open(rqstp, fhp, S_IFREG, MAY_READ, &file);
607         if (err)
608                 goto out;
609         err = nfserr_perm;
610         if (!file.f_op->read)
611                 goto out_close;
612 #ifdef MSNFS
613         if ((fhp->fh_export->ex_flags & NFSEXP_MSNFS) &&
614                 (!lock_may_read(file.f_dentry->d_inode, offset, *count)))
615                 goto out_close;
616 #endif
617
618         /* Get readahead parameters */
619         ra = nfsd_get_raparms(fhp->fh_export->ex_dev, fhp->fh_dentry->d_inode->i_ino);
620         if (ra) {
621                 file.f_reada = ra->p_reada;
622                 file.f_ramax = ra->p_ramax;
623                 file.f_raend = ra->p_raend;
624                 file.f_ralen = ra->p_ralen;
625                 file.f_rawin = ra->p_rawin;
626         }
627         file.f_pos = offset;
628
629         oldfs = get_fs(); set_fs(KERNEL_DS);
630         err = file.f_op->read(&file, buf, *count, &file.f_pos);
631         set_fs(oldfs);
632
633         /* Write back readahead params */
634         if (ra != NULL) {
635                 dprintk("nfsd: raparms %ld %ld %ld %ld %ld\n",
636                         file.f_reada, file.f_ramax, file.f_raend,
637                         file.f_ralen, file.f_rawin);
638                 ra->p_reada = file.f_reada;
639                 ra->p_ramax = file.f_ramax;
640                 ra->p_raend = file.f_raend;
641                 ra->p_ralen = file.f_ralen;
642                 ra->p_rawin = file.f_rawin;
643                 ra->p_count -= 1;
644         }
645
646         if (err >= 0) {
647                 nfsdstats.io_read += err;
648                 *count = err;
649                 err = 0;
650         } else 
651                 err = nfserrno(err);
652 out_close:
653         nfsd_close(&file);
654 out:
655         return err;
656 }
657
658 /*
659  * Write data to a file.
660  * The stable flag requests synchronous writes.
661  * N.B. After this call fhp needs an fh_put
662  */
663 int
664 nfsd_write(struct svc_rqst *rqstp, struct svc_fh *fhp, loff_t offset,
665                                 char *buf, unsigned long cnt, int *stablep)
666 {
667         struct svc_export       *exp;
668         struct file             file;
669         struct dentry           *dentry;
670         struct inode            *inode;
671         mm_segment_t            oldfs;
672         int                     err = 0;
673         int                     stable = *stablep;
674
675         err = nfsd_open(rqstp, fhp, S_IFREG, MAY_WRITE, &file);
676         if (err)
677                 goto out;
678         if (!cnt)
679                 goto out_close;
680         err = nfserr_perm;
681         if (!file.f_op->write)
682                 goto out_close;
683 #ifdef MSNFS
684         if ((fhp->fh_export->ex_flags & NFSEXP_MSNFS) &&
685                 (!lock_may_write(file.f_dentry->d_inode, offset, cnt)))
686                 goto out_close;
687 #endif
688
689         dentry = file.f_dentry;
690         inode = dentry->d_inode;
691         exp   = fhp->fh_export;
692
693         /*
694          * Request sync writes if
695          *  -   the sync export option has been set, or
696          *  -   the client requested O_SYNC behavior (NFSv3 feature).
697          *  -   The file system doesn't support fsync().
698          * When gathered writes have been configured for this volume,
699          * flushing the data to disk is handled separately below.
700          */
701
702         if (file.f_op->fsync == 0) {/* COMMIT3 cannot work */
703                stable = 2;
704                *stablep = 2; /* FILE_SYNC */
705         }
706
707         if (!EX_ISSYNC(exp))
708                 stable = 0;
709         if (stable && !EX_WGATHER(exp))
710                 file.f_flags |= O_SYNC;
711
712         file.f_pos = offset;            /* set write offset */
713
714         /* Write the data. */
715         oldfs = get_fs(); set_fs(KERNEL_DS);
716         err = file.f_op->write(&file, buf, cnt, &file.f_pos);
717         if (err >= 0)
718                 nfsdstats.io_write += cnt;
719         set_fs(oldfs);
720
721         /* clear setuid/setgid flag after write */
722         if (err >= 0 && (inode->i_mode & (S_ISUID | S_ISGID))) {
723                 struct iattr    ia;
724
725                 ia.ia_valid = ATTR_MODE;
726                 ia.ia_mode  = inode->i_mode & ~(S_ISUID | S_ISGID);
727                 notify_change(dentry, &ia);
728         }
729
730         if (err >= 0 && stable) {
731                 static unsigned long    last_ino;
732                 static kdev_t           last_dev = NODEV;
733
734                 /*
735                  * Gathered writes: If another process is currently
736                  * writing to the file, there's a high chance
737                  * this is another nfsd (triggered by a bulk write
738                  * from a client's biod). Rather than syncing the
739                  * file with each write request, we sleep for 10 msec.
740                  *
741                  * I don't know if this roughly approximates
742                  * C. Juszak's idea of gathered writes, but it's a
743                  * nice and simple solution (IMHO), and it seems to
744                  * work:-)
745                  */
746                 if (EX_WGATHER(exp)) {
747                         if (atomic_read(&inode->i_writecount) > 1
748                             || (last_ino == inode->i_ino && last_dev == inode->i_dev)) {
749                                 dprintk("nfsd: write defer %d\n", current->pid);
750                                 set_current_state(TASK_UNINTERRUPTIBLE);
751                                 schedule_timeout((HZ+99)/100);
752                                 current->state = TASK_RUNNING;
753                                 dprintk("nfsd: write resume %d\n", current->pid);
754                         }
755
756                         if (inode->i_state & I_DIRTY) {
757                                 dprintk("nfsd: write sync %d\n", current->pid);
758                                 nfsd_sync(&file);
759                         }
760 #if 0
761                         wake_up(&inode->i_wait);
762 #endif
763                 }
764                 last_ino = inode->i_ino;
765                 last_dev = inode->i_dev;
766         }
767
768         dprintk("nfsd: write complete err=%d\n", err);
769         if (err >= 0)
770                 err = 0;
771         else 
772                 err = nfserrno(err);
773 out_close:
774         nfsd_close(&file);
775 out:
776         return err;
777 }
778
779
780 #ifdef CONFIG_NFSD_V3
781 /*
782  * Commit all pending writes to stable storage.
783  * Strictly speaking, we could sync just the indicated file region here,
784  * but there's currently no way we can ask the VFS to do so.
785  *
786  * Unfortunately we cannot lock the file to make sure we return full WCC
787  * data to the client, as locking happens lower down in the filesystem.
788  */
789 int
790 nfsd_commit(struct svc_rqst *rqstp, struct svc_fh *fhp,
791                off_t offset, unsigned long count)
792 {
793         struct file     file;
794         int             err;
795
796         if ((err = nfsd_open(rqstp, fhp, S_IFREG, MAY_WRITE, &file)) != 0)
797                 return err;
798         if (EX_ISSYNC(fhp->fh_export)) {
799                 if (file.f_op && file.f_op->fsync) {
800                         nfsd_sync(&file);
801                 } else {
802                         err = nfserr_notsupp;
803                 }
804         }
805
806         nfsd_close(&file);
807         return err;
808 }
809 #endif /* CONFIG_NFSD_V3 */
810
811 /*
812  * Create a file (regular, directory, device, fifo); UNIX sockets 
813  * not yet implemented.
814  * If the response fh has been verified, the parent directory should
815  * already be locked. Note that the parent directory is left locked.
816  *
817  * N.B. Every call to nfsd_create needs an fh_put for _both_ fhp and resfhp
818  */
819 int
820 nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
821                 char *fname, int flen, struct iattr *iap,
822                 int type, dev_t rdev, struct svc_fh *resfhp)
823 {
824         struct dentry   *dentry, *dchild;
825         struct inode    *dirp;
826         int             err;
827
828         err = nfserr_perm;
829         if (!flen)
830                 goto out;
831         err = nfserr_exist;
832         if (isdotent(fname, flen))
833                 goto out;
834
835         err = fh_verify(rqstp, fhp, S_IFDIR, MAY_CREATE);
836         if (err)
837                 goto out;
838
839         dentry = fhp->fh_dentry;
840         dirp = dentry->d_inode;
841
842         err = nfserr_notdir;
843         if(!dirp->i_op || !dirp->i_op->lookup)
844                 goto out;
845         /*
846          * Check whether the response file handle has been verified yet.
847          * If it has, the parent directory should already be locked.
848          */
849         if (!resfhp->fh_dentry) {
850                 /* called from nfsd_proc_mkdir, or possibly nfsd3_proc_create */
851                 fh_lock(fhp);
852                 dchild = lookup_one_len(fname, dentry, flen);
853                 err = PTR_ERR(dchild);
854                 if (IS_ERR(dchild))
855                         goto out_nfserr;
856                 err = fh_compose(resfhp, fhp->fh_export, dchild, fhp);
857                 if (err)
858                         goto out;
859         } else {
860                 /* called from nfsd_proc_create */
861                 dchild = resfhp->fh_dentry;
862                 if (!fhp->fh_locked) {
863                         /* not actually possible */
864                         printk(KERN_ERR
865                                 "nfsd_create: parent %s/%s not locked!\n",
866                                 dentry->d_parent->d_name.name,
867                                 dentry->d_name.name);
868                         err = -EIO;
869                         goto out;
870                 }
871         }
872         /*
873          * Make sure the child dentry is still negative ...
874          */
875         err = nfserr_exist;
876         if (dchild->d_inode) {
877                 dprintk("nfsd_create: dentry %s/%s not negative!\n",
878                         dentry->d_name.name, dchild->d_name.name);
879                 goto out; 
880         }
881
882         if (!(iap->ia_valid & ATTR_MODE))
883                 iap->ia_mode = 0;
884         iap->ia_mode = (iap->ia_mode & S_IALLUGO) | type;
885
886         /*
887          * Get the dir op function pointer.
888          */
889         err = nfserr_perm;
890         switch (type) {
891         case S_IFREG:
892                 err = vfs_create(dirp, dchild, iap->ia_mode);
893                 break;
894         case S_IFDIR:
895                 err = vfs_mkdir(dirp, dchild, iap->ia_mode);
896                 break;
897         case S_IFCHR:
898         case S_IFBLK:
899         case S_IFIFO:
900         case S_IFSOCK:
901                 err = vfs_mknod(dirp, dchild, iap->ia_mode, rdev);
902                 break;
903         default:
904                 printk("nfsd: bad file type %o in nfsd_create\n", type);
905                 err = -EINVAL;
906         }
907         if (err < 0)
908                 goto out_nfserr;
909
910         if (EX_ISSYNC(fhp->fh_export)) {
911                 nfsd_sync_dir(dentry);
912                 write_inode_now(dchild->d_inode, 1);
913         }
914
915
916         /* Set file attributes. Mode has already been set and
917          * setting uid/gid works only for root. Irix appears to
918          * send along the gid when it tries to implement setgid
919          * directories via NFS.
920          */
921         err = 0;
922         if ((iap->ia_valid &= ~(ATTR_UID|ATTR_GID|ATTR_MODE)) != 0)
923                 err = nfsd_setattr(rqstp, resfhp, iap, 0, (time_t)0);
924         /*
925          * Update the file handle to get the new inode info.
926          */
927         if (!err)
928                 err = fh_update(resfhp);
929 out:
930         return err;
931
932 out_nfserr:
933         err = nfserrno(err);
934         goto out;
935 }
936
937 #ifdef CONFIG_NFSD_V3
938 /*
939  * NFSv3 version of nfsd_create
940  */
941 int
942 nfsd_create_v3(struct svc_rqst *rqstp, struct svc_fh *fhp,
943                 char *fname, int flen, struct iattr *iap,
944                 struct svc_fh *resfhp, int createmode, u32 *verifier)
945 {
946         struct dentry   *dentry, *dchild;
947         struct inode    *dirp;
948         int             err;
949         __u32           v_mtime=0, v_atime=0;
950         int             v_mode=0;
951
952         err = nfserr_perm;
953         if (!flen)
954                 goto out;
955         err = nfserr_exist;
956         if (isdotent(fname, flen))
957                 goto out;
958         if (!(iap->ia_valid & ATTR_MODE))
959                 iap->ia_mode = 0;
960         err = fh_verify(rqstp, fhp, S_IFDIR, MAY_CREATE);
961         if (err)
962                 goto out;
963
964         dentry = fhp->fh_dentry;
965         dirp = dentry->d_inode;
966
967         /* Get all the sanity checks out of the way before
968          * we lock the parent. */
969         err = nfserr_notdir;
970         if(!dirp->i_op || !dirp->i_op->lookup)
971                 goto out;
972         fh_lock(fhp);
973
974         /*
975          * Compose the response file handle.
976          */
977         dchild = lookup_one_len(fname, dentry, flen);
978         err = PTR_ERR(dchild);
979         if (IS_ERR(dchild))
980                 goto out_nfserr;
981
982         err = fh_compose(resfhp, fhp->fh_export, dchild, fhp);
983         if (err)
984                 goto out;
985
986         if (createmode == NFS3_CREATE_EXCLUSIVE) {
987                 /* while the verifier would fit in mtime+atime,
988                  * solaris7 gets confused (bugid 4218508) if these have
989                  * the high bit set, so we use the mode as well
990                  */
991                 v_mtime = verifier[0]&0x7fffffff;
992                 v_atime = verifier[1]&0x7fffffff;
993                 v_mode  = S_IFREG
994                         | ((verifier[0]&0x80000000) >> (32-7)) /* u+x */
995                         | ((verifier[1]&0x80000000) >> (32-9)) /* u+r */
996                         ;
997         }
998         
999         if (dchild->d_inode) {
1000                 err = 0;
1001
1002                 switch (createmode) {
1003                 case NFS3_CREATE_UNCHECKED:
1004                         if (! S_ISREG(dchild->d_inode->i_mode))
1005                                 err = nfserr_exist;
1006                         else {
1007                                 iap->ia_valid &= ATTR_SIZE;
1008                                 goto set_attr;
1009                         }
1010                         break;
1011                 case NFS3_CREATE_EXCLUSIVE:
1012                         if (   dchild->d_inode->i_mtime == v_mtime
1013                             && dchild->d_inode->i_atime == v_atime
1014                             && dchild->d_inode->i_mode  == v_mode
1015                             && dchild->d_inode->i_size  == 0 )
1016                                 break;
1017                          /* fallthru */
1018                 case NFS3_CREATE_GUARDED:
1019                         err = nfserr_exist;
1020                 }
1021                 goto out;
1022         }
1023
1024         err = vfs_create(dirp, dchild, iap->ia_mode);
1025         if (err < 0)
1026                 goto out_nfserr;
1027
1028         if (EX_ISSYNC(fhp->fh_export)) {
1029                 nfsd_sync_dir(dentry);
1030                 /* setattr will sync the child (or not) */
1031         }
1032
1033         /*
1034          * Update the filehandle to get the new inode info.
1035          */
1036         err = fh_update(resfhp);
1037         if (err)
1038                 goto out;
1039
1040         if (createmode == NFS3_CREATE_EXCLUSIVE) {
1041                 /* Cram the verifier into atime/mtime/mode */
1042                 iap->ia_valid = ATTR_MTIME|ATTR_ATIME
1043                         | ATTR_MTIME_SET|ATTR_ATIME_SET
1044                         | ATTR_MODE;
1045                 iap->ia_mtime = v_mtime;
1046                 iap->ia_atime = v_atime;
1047                 iap->ia_mode  = v_mode;
1048         }
1049
1050         /* Set file attributes.
1051          * Mode has already been set but we might need to reset it
1052          * for CREATE_EXCLUSIVE
1053          * Irix appears to send along the gid when it tries to
1054          * implement setgid directories via NFS. Clear out all that cruft.
1055          */
1056  set_attr:
1057         if ((iap->ia_valid &= ~(ATTR_UID|ATTR_GID)) != 0)
1058                 err = nfsd_setattr(rqstp, resfhp, iap, 0, (time_t)0);
1059
1060  out:
1061         fh_unlock(fhp);
1062         return err;
1063  
1064  out_nfserr:
1065         err = nfserrno(err);
1066         goto out;
1067 }
1068 #endif /* CONFIG_NFSD_V3 */
1069
1070 /*
1071  * Read a symlink. On entry, *lenp must contain the maximum path length that
1072  * fits into the buffer. On return, it contains the true length.
1073  * N.B. After this call fhp needs an fh_put
1074  */
1075 int
1076 nfsd_readlink(struct svc_rqst *rqstp, struct svc_fh *fhp, char *buf, int *lenp)
1077 {
1078         struct dentry   *dentry;
1079         struct inode    *inode;
1080         mm_segment_t    oldfs;
1081         int             err;
1082
1083         err = fh_verify(rqstp, fhp, S_IFLNK, MAY_NOP);
1084         if (err)
1085                 goto out;
1086
1087         dentry = fhp->fh_dentry;
1088         inode = dentry->d_inode;
1089
1090         err = nfserr_inval;
1091         if (!inode->i_op || !inode->i_op->readlink)
1092                 goto out;
1093
1094         UPDATE_ATIME(inode);
1095         /* N.B. Why does this call need a get_fs()??
1096          * Remove the set_fs and watch the fireworks:-) --okir
1097          */
1098
1099         oldfs = get_fs(); set_fs(KERNEL_DS);
1100         err = inode->i_op->readlink(dentry, buf, *lenp);
1101         set_fs(oldfs);
1102
1103         if (err < 0)
1104                 goto out_nfserr;
1105         *lenp = err;
1106         err = 0;
1107 out:
1108         return err;
1109
1110 out_nfserr:
1111         err = nfserrno(err);
1112         goto out;
1113 }
1114
1115 /*
1116  * Create a symlink and look up its inode
1117  * N.B. After this call _both_ fhp and resfhp need an fh_put
1118  */
1119 int
1120 nfsd_symlink(struct svc_rqst *rqstp, struct svc_fh *fhp,
1121                                 char *fname, int flen,
1122                                 char *path,  int plen,
1123                                 struct svc_fh *resfhp,
1124                                 struct iattr *iap)
1125 {
1126         struct dentry   *dentry, *dnew;
1127         int             err, cerr;
1128
1129         err = nfserr_noent;
1130         if (!flen || !plen)
1131                 goto out;
1132         err = nfserr_exist;
1133         if (isdotent(fname, flen))
1134                 goto out;
1135
1136         err = fh_verify(rqstp, fhp, S_IFDIR, MAY_CREATE);
1137         if (err)
1138                 goto out;
1139         fh_lock(fhp);
1140         dentry = fhp->fh_dentry;
1141         dnew = lookup_one_len(fname, dentry, flen);
1142         err = PTR_ERR(dnew);
1143         if (IS_ERR(dnew))
1144                 goto out_nfserr;
1145
1146         err = vfs_symlink(dentry->d_inode, dnew, path);
1147         if (!err) {
1148                 if (EX_ISSYNC(fhp->fh_export))
1149                         nfsd_sync_dir(dentry);
1150                 if (iap) {
1151                         iap->ia_valid &= ATTR_MODE /* ~(ATTR_MODE|ATTR_UID|ATTR_GID)*/;
1152                         if (iap->ia_valid) {
1153                                 iap->ia_valid |= ATTR_CTIME;
1154                                 iap->ia_mode = (iap->ia_mode&S_IALLUGO)
1155                                         | S_IFLNK;
1156                                 err = notify_change(dnew, iap);
1157                                 if (!err && EX_ISSYNC(fhp->fh_export))
1158                                         write_inode_now(dentry->d_inode, 1);
1159                        }
1160                 }
1161         } else
1162                 err = nfserrno(err);
1163         fh_unlock(fhp);
1164
1165         /* Compose the fh so the dentry will be freed ... */
1166         cerr = fh_compose(resfhp, fhp->fh_export, dnew, fhp);
1167         if (err==0) err = cerr;
1168 out:
1169         return err;
1170
1171 out_nfserr:
1172         err = nfserrno(err);
1173         goto out;
1174 }
1175
1176 /*
1177  * Create a hardlink
1178  * N.B. After this call _both_ ffhp and tfhp need an fh_put
1179  */
1180 int
1181 nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,
1182                                 char *fname, int len, struct svc_fh *tfhp)
1183 {
1184         struct dentry   *ddir, *dnew, *dold;
1185         struct inode    *dirp, *dest;
1186         int             err;
1187
1188         err = fh_verify(rqstp, ffhp, S_IFDIR, MAY_CREATE);
1189         if (err)
1190                 goto out;
1191         err = fh_verify(rqstp, tfhp, -S_IFDIR, MAY_NOP);
1192         if (err)
1193                 goto out;
1194
1195         err = nfserr_perm;
1196         if (!len)
1197                 goto out;
1198         err = nfserr_exist;
1199         if (isdotent(fname, len))
1200                 goto out;
1201
1202         fh_lock(ffhp);
1203         ddir = ffhp->fh_dentry;
1204         dirp = ddir->d_inode;
1205
1206         dnew = lookup_one_len(fname, ddir, len);
1207         err = PTR_ERR(dnew);
1208         if (IS_ERR(dnew))
1209                 goto out_nfserr;
1210
1211         dold = tfhp->fh_dentry;
1212         dest = dold->d_inode;
1213
1214         err = vfs_link(dold, dirp, dnew);
1215         if (!err) {
1216                 if (EX_ISSYNC(ffhp->fh_export)) {
1217                         nfsd_sync_dir(ddir);
1218                         write_inode_now(dest, 1);
1219                 }
1220         } else {
1221                 if (err == -EXDEV && rqstp->rq_vers == 2)
1222                         err = nfserr_acces;
1223                 else
1224                         err = nfserrno(err);
1225         }
1226
1227         fh_unlock(ffhp);
1228         dput(dnew);
1229 out:
1230         return err;
1231
1232 out_nfserr:
1233         err = nfserrno(err);
1234         goto out;
1235 }
1236
1237 /*
1238  * Rename a file
1239  * N.B. After this call _both_ ffhp and tfhp need an fh_put
1240  */
1241 int
1242 nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen,
1243                             struct svc_fh *tfhp, char *tname, int tlen)
1244 {
1245         struct dentry   *fdentry, *tdentry, *odentry, *ndentry;
1246         struct inode    *fdir, *tdir;
1247         int             err;
1248
1249         err = fh_verify(rqstp, ffhp, S_IFDIR, MAY_REMOVE);
1250         if (err)
1251                 goto out;
1252         err = fh_verify(rqstp, tfhp, S_IFDIR, MAY_CREATE);
1253         if (err)
1254                 goto out;
1255
1256         fdentry = ffhp->fh_dentry;
1257         fdir = fdentry->d_inode;
1258
1259         tdentry = tfhp->fh_dentry;
1260         tdir = tdentry->d_inode;
1261
1262         err = (rqstp->rq_vers == 2) ? nfserr_acces : nfserr_xdev;
1263         if (fdir->i_dev != tdir->i_dev)
1264                 goto out;
1265
1266         err = nfserr_perm;
1267         if (!flen || isdotent(fname, flen) || !tlen || isdotent(tname, tlen))
1268                 goto out;
1269
1270         /* cannot use fh_lock as we need deadlock protective ordering
1271          * so do it by hand */
1272         double_down(&tdir->i_sem, &fdir->i_sem);
1273         ffhp->fh_locked = tfhp->fh_locked = 1;
1274         fill_pre_wcc(ffhp);
1275         fill_pre_wcc(tfhp);
1276
1277         odentry = lookup_one_len(fname, fdentry, flen);
1278         err = PTR_ERR(odentry);
1279         if (IS_ERR(odentry))
1280                 goto out_nfserr;
1281
1282         err = -ENOENT;
1283         if (!odentry->d_inode)
1284                 goto out_dput_old;
1285
1286         ndentry = lookup_one_len(tname, tdentry, tlen);
1287         err = PTR_ERR(ndentry);
1288         if (IS_ERR(ndentry))
1289                 goto out_dput_old;
1290
1291
1292 #ifdef MSNFS
1293         if ((ffhp->fh_export->ex_flags & NFSEXP_MSNFS) &&
1294                 ((atomic_read(&odentry->d_count) > 1)
1295                  || (atomic_read(&ndentry->d_count) > 1))) {
1296                         err = nfserr_perm;
1297         } else
1298 #endif
1299         err = vfs_rename(fdir, odentry, tdir, ndentry);
1300         if (!err && EX_ISSYNC(tfhp->fh_export)) {
1301                 nfsd_sync_dir(tdentry);
1302                 nfsd_sync_dir(fdentry);
1303         }
1304         dput(ndentry);
1305
1306  out_dput_old:
1307         dput(odentry);
1308  out_nfserr:
1309         if (err)
1310                 err = nfserrno(err);
1311
1312         /* we cannot reply on fh_unlock on the two filehandles,
1313          * as that would do the wrong thing if the two directories
1314          * were the same, so again we do it by hand
1315          */
1316         fill_post_wcc(ffhp);
1317         fill_post_wcc(tfhp);
1318         double_up(&tdir->i_sem, &fdir->i_sem);
1319         ffhp->fh_locked = tfhp->fh_locked = 0;
1320         
1321 out:
1322         return err;
1323 }
1324
1325 /*
1326  * Unlink a file or directory
1327  * N.B. After this call fhp needs an fh_put
1328  */
1329 int
1330 nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
1331                                 char *fname, int flen)
1332 {
1333         struct dentry   *dentry, *rdentry;
1334         struct inode    *dirp;
1335         int             err;
1336
1337         err = nfserr_acces;
1338         if (!flen || isdotent(fname, flen))
1339                 goto out;
1340         err = fh_verify(rqstp, fhp, S_IFDIR, MAY_REMOVE);
1341         if (err)
1342                 goto out;
1343
1344         fh_lock(fhp);
1345         dentry = fhp->fh_dentry;
1346         dirp = dentry->d_inode;
1347
1348         rdentry = lookup_one_len(fname, dentry, flen);
1349         err = PTR_ERR(rdentry);
1350         if (IS_ERR(rdentry))
1351                 goto out_nfserr;
1352
1353         if (!rdentry->d_inode) {
1354                 dput(rdentry);
1355                 err = nfserr_noent;
1356                 goto out;
1357         }
1358
1359         if (type != S_IFDIR) { /* It's UNLINK */
1360 #ifdef MSNFS
1361                 if ((fhp->fh_export->ex_flags & NFSEXP_MSNFS) &&
1362                         (atomic_read(&rdentry->d_count) > 1)) {
1363                         err = nfserr_perm;
1364                 } else
1365 #endif
1366                 err = vfs_unlink(dirp, rdentry);
1367         } else { /* It's RMDIR */
1368                 err = vfs_rmdir(dirp, rdentry);
1369         }
1370
1371         dput(rdentry);
1372
1373         if (err)
1374                 goto out_nfserr;
1375         if (EX_ISSYNC(fhp->fh_export)) 
1376                 nfsd_sync_dir(dentry);
1377
1378 out:
1379         return err;
1380
1381 out_nfserr:
1382         err = nfserrno(err);
1383         goto out;
1384 }
1385
1386 /*
1387  * Read entries from a directory.
1388  * The verifier is an NFSv3 thing we ignore for now.
1389  */
1390 int
1391 nfsd_readdir(struct svc_rqst *rqstp, struct svc_fh *fhp, loff_t offset, 
1392              encode_dent_fn func, u32 *buffer, int *countp, u32 *verf)
1393 {
1394         struct inode    *inode;
1395         u32             *p;
1396         int             oldlen, eof, err;
1397         struct file     file;
1398         struct readdir_cd cd;
1399
1400         err = nfsd_open(rqstp, fhp, S_IFDIR, MAY_READ, &file);
1401         if (err)
1402                 goto out;
1403         if (offset > ~(u32) 0)
1404                 goto out_close;
1405
1406         err = nfserr_notdir;
1407         if (!file.f_op->readdir)
1408                 goto out_close;
1409         file.f_pos = offset;
1410
1411         /* Set up the readdir context */
1412         memset(&cd, 0, sizeof(cd));
1413         cd.rqstp  = rqstp;
1414         cd.buffer = buffer;
1415         cd.buflen = *countp; /* count of words */
1416         cd.dirfh  = fhp;
1417
1418         /*
1419          * Read the directory entries. This silly loop is necessary because
1420          * readdir() is not guaranteed to fill up the entire buffer, but
1421          * may choose to do less.
1422          */
1423         inode = file.f_dentry->d_inode;
1424         down(&inode->i_sem);
1425         while (1) {
1426                 oldlen = cd.buflen;
1427
1428                 /*
1429                 dprintk("nfsd: f_op->readdir(%x/%ld @ %d) buflen = %d (%d)\n",
1430                         file.f_inode->i_dev, file.f_inode->i_ino,
1431                         (int) file.f_pos, (int) oldlen, (int) cd.buflen);
1432                  */
1433                 err = file.f_op->readdir(&file, &cd, (filldir_t) func);
1434                 if (err < 0)
1435                         goto out_nfserr;
1436                 if (oldlen == cd.buflen)
1437                         break;
1438                 if (cd.eob)
1439                         break;
1440         }
1441         up(&inode->i_sem);
1442
1443         /* If we didn't fill the buffer completely, we're at EOF */
1444         eof = !cd.eob;
1445
1446         if (cd.offset) {
1447                 if (rqstp->rq_vers == 3)
1448                         (void)xdr_encode_hyper(cd.offset, file.f_pos);
1449                 else
1450                         *cd.offset = htonl(file.f_pos);
1451         }
1452
1453         p = cd.buffer;
1454         *p++ = 0;                       /* no more entries */
1455         *p++ = htonl(eof);              /* end of directory */
1456         *countp = (caddr_t) p - (caddr_t) buffer;
1457
1458         dprintk("nfsd: readdir result %d bytes, eof %d offset %d\n",
1459                                 *countp, eof,
1460                                 cd.offset? ntohl(*cd.offset) : -1);
1461         err = 0;
1462 out_close:
1463         nfsd_close(&file);
1464 out:
1465         return err;
1466
1467 out_nfserr:
1468         up(&inode->i_sem);
1469         err = nfserrno(err);
1470         goto out_close;
1471 }
1472
1473 /*
1474  * Get file system stats
1475  * N.B. After this call fhp needs an fh_put
1476  */
1477 int
1478 nfsd_statfs(struct svc_rqst *rqstp, struct svc_fh *fhp, struct statfs *stat)
1479 {
1480         int err = fh_verify(rqstp, fhp, 0, MAY_NOP);
1481         if (!err && vfs_statfs(fhp->fh_dentry->d_inode->i_sb,stat))
1482                 err = nfserr_io;
1483         return err;
1484 }
1485
1486 /*
1487  * Check for a user's access permissions to this inode.
1488  */
1489 int
1490 nfsd_permission(struct svc_export *exp, struct dentry *dentry, int acc)
1491 {
1492         struct inode    *inode = dentry->d_inode;
1493         int             err;
1494
1495         if (acc == MAY_NOP)
1496                 return 0;
1497 #if 0
1498         dprintk("nfsd: permission 0x%x%s%s%s%s%s%s%s mode 0%o%s%s%s\n",
1499                 acc,
1500                 (acc & MAY_READ)?       " read"  : "",
1501                 (acc & MAY_WRITE)?      " write" : "",
1502                 (acc & MAY_EXEC)?       " exec"  : "",
1503                 (acc & MAY_SATTR)?      " sattr" : "",
1504                 (acc & MAY_TRUNC)?      " trunc" : "",
1505                 (acc & MAY_LOCK)?       " lock"  : "",
1506                 (acc & MAY_OWNER_OVERRIDE)? " owneroverride" : "",
1507                 inode->i_mode,
1508                 IS_IMMUTABLE(inode)?    " immut" : "",
1509                 IS_APPEND(inode)?       " append" : "",
1510                 IS_RDONLY(inode)?       " ro" : "");
1511         dprintk("      owner %d/%d user %d/%d\n",
1512                 inode->i_uid, inode->i_gid, current->fsuid, current->fsgid);
1513 #endif
1514
1515         /* only care about readonly exports for files and
1516          * directories. links don't have meaningful write access,
1517          * and all else is local to the client
1518          */
1519         if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)) 
1520                 if (acc & (MAY_WRITE | MAY_SATTR | MAY_TRUNC)) {
1521                         if (EX_RDONLY(exp) || IS_RDONLY(inode))
1522                                 return nfserr_rofs;
1523                         if (/* (acc & MAY_WRITE) && */ IS_IMMUTABLE(inode))
1524                                 return nfserr_perm;
1525                 }
1526         if ((acc & MAY_TRUNC) && IS_APPEND(inode))
1527                 return nfserr_perm;
1528
1529         if (acc & MAY_LOCK) {
1530                 /* If we cannot rely on authentication in NLM requests,
1531                  * just allow locks, otherwise require read permission, or
1532                  * ownership
1533                  */
1534                 if (exp->ex_flags & NFSEXP_NOAUTHNLM)
1535                         return 0;
1536                 else
1537                         acc = MAY_READ | MAY_OWNER_OVERRIDE;
1538         }
1539         /*
1540          * The file owner always gets access permission for accesses that
1541          * would normally be checked at open time. This is to make
1542          * file access work even when the client has done a fchmod(fd, 0).
1543          *
1544          * However, `cp foo bar' should fail nevertheless when bar is
1545          * readonly. A sensible way to do this might be to reject all
1546          * attempts to truncate a read-only file, because a creat() call
1547          * always implies file truncation.
1548          * ... but this isn't really fair.  A process may reasonably call
1549          * ftruncate on an open file descriptor on a file with perm 000.
1550          * We must trust the client to do permission checking - using "ACCESS"
1551          * with NFSv3.
1552          */
1553         if ((acc & MAY_OWNER_OVERRIDE) &&
1554             inode->i_uid == current->fsuid)
1555                 return 0;
1556
1557         acc &= ~ MAY_OWNER_OVERRIDE; /* This bit is no longer needed,
1558                                         and gets in the way later */
1559
1560         err = permission(inode, acc & (MAY_READ|MAY_WRITE|MAY_EXEC));
1561
1562         /* Allow read access to binaries even when mode 111 */
1563         if (err == -EACCES && S_ISREG(inode->i_mode) && acc == MAY_READ)
1564                 err = permission(inode, MAY_EXEC);
1565
1566         return err? nfserrno(err) : 0;
1567 }
1568
1569 void
1570 nfsd_racache_shutdown(void)
1571 {
1572         if (!raparm_cache)
1573                 return;
1574         dprintk("nfsd: freeing readahead buffers.\n");
1575         kfree(raparml);
1576         raparm_cache = raparml = NULL;
1577 }
1578 /*
1579  * Initialize readahead param cache
1580  */
1581 int
1582 nfsd_racache_init(int cache_size)
1583 {
1584         int     i;
1585
1586         if (raparm_cache)
1587                 return 0;
1588         raparml = kmalloc(sizeof(struct raparms) * cache_size, GFP_KERNEL);
1589
1590         if (raparml != NULL) {
1591                 dprintk("nfsd: allocating %d readahead buffers.\n",
1592                         cache_size);
1593                 memset(raparml, 0, sizeof(struct raparms) * cache_size);
1594                 for (i = 0; i < cache_size - 1; i++) {
1595                         raparml[i].p_next = raparml + i + 1;
1596                 }
1597                 raparm_cache = raparml;
1598         } else {
1599                 printk(KERN_WARNING
1600                        "nfsd: Could not allocate memory read-ahead cache.\n");
1601                 return -ENOMEM;
1602         }
1603         nfsdstats.ra_size = cache_size;
1604         return 0;
1605 }