a10aa70536f047bbc6c9f3d94cbb170edb90e931
[dragonfly.git] / sys / vfs / nfs / nfs_bio.c
1 /*
2  * Copyright (c) 1989, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Rick Macklem at The University of Guelph.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *      This product includes software developed by the University of
19  *      California, Berkeley and its contributors.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  *
36  *      @(#)nfs_bio.c   8.9 (Berkeley) 3/30/95
37  * $FreeBSD: /repoman/r/ncvs/src/sys/nfsclient/nfs_bio.c,v 1.130 2004/04/14 23:23:55 peadar Exp $
38  * $DragonFly: src/sys/vfs/nfs/nfs_bio.c,v 1.45 2008/07/18 00:09:39 dillon Exp $
39  */
40
41
42 #include <sys/param.h>
43 #include <sys/systm.h>
44 #include <sys/resourcevar.h>
45 #include <sys/signalvar.h>
46 #include <sys/proc.h>
47 #include <sys/buf.h>
48 #include <sys/vnode.h>
49 #include <sys/mount.h>
50 #include <sys/kernel.h>
51 #include <sys/buf2.h>
52 #include <sys/msfbuf.h>
53
54 #include <vm/vm.h>
55 #include <vm/vm_extern.h>
56 #include <vm/vm_page.h>
57 #include <vm/vm_object.h>
58 #include <vm/vm_pager.h>
59 #include <vm/vnode_pager.h>
60
61 #include <sys/thread2.h>
62
63 #include "rpcv2.h"
64 #include "nfsproto.h"
65 #include "nfs.h"
66 #include "nfsmount.h"
67 #include "nfsnode.h"
68
69 static struct buf *nfs_getcacheblk(struct vnode *vp, off_t loffset,
70                                    int size, struct thread *td);
71 static int nfs_check_dirent(struct nfs_dirent *dp, int maxlen);
72 static void nfsiodone_sync(struct bio *bio);
73
74 /*
75  * Vnode op for VM getpages.
76  *
77  * nfs_getpages(struct vnode *a_vp, vm_page_t *a_m, int a_count,
78  *              int a_reqpage, vm_ooffset_t a_offset)
79  */
80 int
81 nfs_getpages(struct vop_getpages_args *ap)
82 {
83         struct thread *td = curthread;          /* XXX */
84         int i, error, nextoff, size, toff, count, npages;
85         struct uio uio;
86         struct iovec iov;
87         char *kva;
88         struct vnode *vp;
89         struct nfsmount *nmp;
90         vm_page_t *pages;
91         vm_page_t m;
92         struct msf_buf *msf;
93
94         vp = ap->a_vp;
95         nmp = VFSTONFS(vp->v_mount);
96         pages = ap->a_m;
97         count = ap->a_count;
98
99         if (vp->v_object == NULL) {
100                 kprintf("nfs_getpages: called with non-merged cache vnode??\n");
101                 return VM_PAGER_ERROR;
102         }
103
104         if ((nmp->nm_flag & NFSMNT_NFSV3) != 0 &&
105             (nmp->nm_state & NFSSTA_GOTFSINFO) == 0)
106                 (void)nfs_fsinfo(nmp, vp, td);
107
108         npages = btoc(count);
109
110         /*
111          * NOTE that partially valid pages may occur in cases other
112          * then file EOF, such as when a file is partially written and
113          * ftruncate()-extended to a larger size.   It is also possible
114          * for the valid bits to be set on garbage beyond the file EOF and
115          * clear in the area before EOF (e.g. m->valid == 0xfc), which can
116          * occur due to vtruncbuf() and the buffer cache's handling of
117          * pages which 'straddle' buffers or when b_bufsize is not a 
118          * multiple of PAGE_SIZE.... the buffer cache cannot normally
119          * clear the extra bits.  This kind of situation occurs when you
120          * make a small write() (m->valid == 0x03) and then mmap() and
121          * fault in the buffer(m->valid = 0xFF).  When NFS flushes the
122          * buffer (vinvalbuf() m->valid = 0xFC) we are left with a mess.
123          *
124          * This is combined with the possibility that the pages are partially
125          * dirty or that there is a buffer backing the pages that is dirty
126          * (even if m->dirty is 0).
127          *
128          * To solve this problem several hacks have been made:  (1) NFS
129          * guarentees that the IO block size is a multiple of PAGE_SIZE and
130          * (2) The buffer cache, when invalidating an NFS buffer, will
131          * disregard the buffer's fragmentory b_bufsize and invalidate
132          * the whole page rather then just the piece the buffer owns.
133          *
134          * This allows us to assume that a partially valid page found here
135          * is fully valid (vm_fault will zero'd out areas of the page not
136          * marked as valid).
137          */
138         m = pages[ap->a_reqpage];
139         if (m->valid != 0) {
140                 for (i = 0; i < npages; ++i) {
141                         if (i != ap->a_reqpage)
142                                 vnode_pager_freepage(pages[i]);
143                 }
144                 return(0);
145         }
146
147         /*
148          * Use an MSF_BUF as a medium to retrieve data from the pages.
149          */
150         msf_map_pagelist(&msf, pages, npages, 0);
151         KKASSERT(msf);
152         kva = msf_buf_kva(msf);
153
154         iov.iov_base = kva;
155         iov.iov_len = count;
156         uio.uio_iov = &iov;
157         uio.uio_iovcnt = 1;
158         uio.uio_offset = IDX_TO_OFF(pages[0]->pindex);
159         uio.uio_resid = count;
160         uio.uio_segflg = UIO_SYSSPACE;
161         uio.uio_rw = UIO_READ;
162         uio.uio_td = td;
163
164         error = nfs_readrpc(vp, &uio);
165         msf_buf_free(msf);
166
167         if (error && (uio.uio_resid == count)) {
168                 kprintf("nfs_getpages: error %d\n", error);
169                 for (i = 0; i < npages; ++i) {
170                         if (i != ap->a_reqpage)
171                                 vnode_pager_freepage(pages[i]);
172                 }
173                 return VM_PAGER_ERROR;
174         }
175
176         /*
177          * Calculate the number of bytes read and validate only that number
178          * of bytes.  Note that due to pending writes, size may be 0.  This
179          * does not mean that the remaining data is invalid!
180          */
181
182         size = count - uio.uio_resid;
183
184         for (i = 0, toff = 0; i < npages; i++, toff = nextoff) {
185                 nextoff = toff + PAGE_SIZE;
186                 m = pages[i];
187
188                 m->flags &= ~PG_ZERO;
189
190                 if (nextoff <= size) {
191                         /*
192                          * Read operation filled an entire page
193                          */
194                         m->valid = VM_PAGE_BITS_ALL;
195                         vm_page_undirty(m);
196                 } else if (size > toff) {
197                         /*
198                          * Read operation filled a partial page.
199                          */
200                         m->valid = 0;
201                         vm_page_set_validclean(m, 0, size - toff);
202                         /* handled by vm_fault now        */
203                         /* vm_page_zero_invalid(m, TRUE); */
204                 } else {
205                         /*
206                          * Read operation was short.  If no error occured
207                          * we may have hit a zero-fill section.   We simply
208                          * leave valid set to 0.
209                          */
210                         ;
211                 }
212                 if (i != ap->a_reqpage) {
213                         /*
214                          * Whether or not to leave the page activated is up in
215                          * the air, but we should put the page on a page queue
216                          * somewhere (it already is in the object).  Result:
217                          * It appears that emperical results show that
218                          * deactivating pages is best.
219                          */
220
221                         /*
222                          * Just in case someone was asking for this page we
223                          * now tell them that it is ok to use.
224                          */
225                         if (!error) {
226                                 if (m->flags & PG_WANTED)
227                                         vm_page_activate(m);
228                                 else
229                                         vm_page_deactivate(m);
230                                 vm_page_wakeup(m);
231                         } else {
232                                 vnode_pager_freepage(m);
233                         }
234                 }
235         }
236         return 0;
237 }
238
239 /*
240  * Vnode op for VM putpages.
241  *
242  * nfs_putpages(struct vnode *a_vp, vm_page_t *a_m, int a_count, int a_sync,
243  *              int *a_rtvals, vm_ooffset_t a_offset)
244  */
245 int
246 nfs_putpages(struct vop_putpages_args *ap)
247 {
248         struct thread *td = curthread;
249         struct uio uio;
250         struct iovec iov;
251         char *kva;
252         int iomode, must_commit, i, error, npages, count;
253         off_t offset;
254         int *rtvals;
255         struct vnode *vp;
256         struct nfsmount *nmp;
257         struct nfsnode *np;
258         vm_page_t *pages;
259         struct msf_buf *msf;
260
261         vp = ap->a_vp;
262         np = VTONFS(vp);
263         nmp = VFSTONFS(vp->v_mount);
264         pages = ap->a_m;
265         count = ap->a_count;
266         rtvals = ap->a_rtvals;
267         npages = btoc(count);
268         offset = IDX_TO_OFF(pages[0]->pindex);
269
270         if ((nmp->nm_flag & NFSMNT_NFSV3) != 0 &&
271             (nmp->nm_state & NFSSTA_GOTFSINFO) == 0)
272                 (void)nfs_fsinfo(nmp, vp, td);
273
274         for (i = 0; i < npages; i++) {
275                 rtvals[i] = VM_PAGER_AGAIN;
276         }
277
278         /*
279          * When putting pages, do not extend file past EOF.
280          */
281
282         if (offset + count > np->n_size) {
283                 count = np->n_size - offset;
284                 if (count < 0)
285                         count = 0;
286         }
287
288         /*
289          * Use an MSF_BUF as a medium to retrieve data from the pages.
290          */
291         msf_map_pagelist(&msf, pages, npages, 0);
292         KKASSERT(msf);
293         kva = msf_buf_kva(msf);
294
295         iov.iov_base = kva;
296         iov.iov_len = count;
297         uio.uio_iov = &iov;
298         uio.uio_iovcnt = 1;
299         uio.uio_offset = offset;
300         uio.uio_resid = count;
301         uio.uio_segflg = UIO_SYSSPACE;
302         uio.uio_rw = UIO_WRITE;
303         uio.uio_td = td;
304
305         if ((ap->a_sync & VM_PAGER_PUT_SYNC) == 0)
306             iomode = NFSV3WRITE_UNSTABLE;
307         else
308             iomode = NFSV3WRITE_FILESYNC;
309
310         error = nfs_writerpc(vp, &uio, &iomode, &must_commit);
311
312         msf_buf_free(msf);
313
314         if (!error) {
315                 int nwritten = round_page(count - uio.uio_resid) / PAGE_SIZE;
316                 for (i = 0; i < nwritten; i++) {
317                         rtvals[i] = VM_PAGER_OK;
318                         vm_page_undirty(pages[i]);
319                 }
320                 if (must_commit)
321                         nfs_clearcommit(vp->v_mount);
322         }
323         return rtvals[0];
324 }
325
326 /*
327  * Vnode op for read using bio
328  */
329 int
330 nfs_bioread(struct vnode *vp, struct uio *uio, int ioflag)
331 {
332         struct nfsnode *np = VTONFS(vp);
333         int biosize, i;
334         struct buf *bp = 0, *rabp;
335         struct vattr vattr;
336         struct thread *td;
337         struct nfsmount *nmp = VFSTONFS(vp->v_mount);
338         daddr_t lbn, rabn;
339         off_t raoffset;
340         off_t loffset;
341         int bcount;
342         int seqcount;
343         int nra, error = 0, n = 0, on = 0;
344
345 #ifdef DIAGNOSTIC
346         if (uio->uio_rw != UIO_READ)
347                 panic("nfs_read mode");
348 #endif
349         if (uio->uio_resid == 0)
350                 return (0);
351         if (uio->uio_offset < 0)        /* XXX VDIR cookies can be negative */
352                 return (EINVAL);
353         td = uio->uio_td;
354
355         if ((nmp->nm_flag & NFSMNT_NFSV3) != 0 &&
356             (nmp->nm_state & NFSSTA_GOTFSINFO) == 0)
357                 (void)nfs_fsinfo(nmp, vp, td);
358         if (vp->v_type != VDIR &&
359             (uio->uio_offset + uio->uio_resid) > nmp->nm_maxfilesize)
360                 return (EFBIG);
361         biosize = vp->v_mount->mnt_stat.f_iosize;
362         seqcount = (int)((off_t)(ioflag >> IO_SEQSHIFT) * biosize / BKVASIZE);
363
364         /*
365          * For nfs, cache consistency can only be maintained approximately.
366          * Although RFC1094 does not specify the criteria, the following is
367          * believed to be compatible with the reference port.
368          *
369          * NFS:         If local changes have been made and this is a
370          *              directory, the directory must be invalidated and
371          *              the attribute cache must be cleared.
372          *
373          *              GETATTR is called to synchronize the file size.
374          *
375          *              If remote changes are detected local data is flushed
376          *              and the cache is invalidated.
377          *
378          *              NOTE: In the normal case the attribute cache is not
379          *              cleared which means GETATTR may use cached data and
380          *              not immediately detect changes made on the server.
381          */
382         if ((np->n_flag & NLMODIFIED) && vp->v_type == VDIR) {
383                 nfs_invaldir(vp);
384                 error = nfs_vinvalbuf(vp, V_SAVE, 1);
385                 if (error)
386                         return (error);
387                 np->n_attrstamp = 0;
388         }
389         error = VOP_GETATTR(vp, &vattr);
390         if (error)
391                 return (error);
392         if (np->n_flag & NRMODIFIED) {
393                 if (vp->v_type == VDIR)
394                         nfs_invaldir(vp);
395                 error = nfs_vinvalbuf(vp, V_SAVE, 1);
396                 if (error)
397                         return (error);
398                 np->n_flag &= ~NRMODIFIED;
399         }
400         do {
401             if (np->n_flag & NDONTCACHE) {
402                 switch (vp->v_type) {
403                 case VREG:
404                         return (nfs_readrpc(vp, uio));
405                 case VLNK:
406                         return (nfs_readlinkrpc(vp, uio));
407                 case VDIR:
408                         break;
409                 default:
410                         kprintf(" NDONTCACHE: type %x unexpected\n", vp->v_type);
411                         break;
412                 };
413             }
414             switch (vp->v_type) {
415             case VREG:
416                 nfsstats.biocache_reads++;
417                 lbn = uio->uio_offset / biosize;
418                 on = uio->uio_offset & (biosize - 1);
419                 loffset = (off_t)lbn * biosize;
420
421                 /*
422                  * Start the read ahead(s), as required.
423                  */
424                 if (nmp->nm_readahead > 0) {
425                     for (nra = 0; nra < nmp->nm_readahead && nra < seqcount &&
426                         (off_t)(lbn + 1 + nra) * biosize < np->n_size; nra++) {
427                         rabn = lbn + 1 + nra;
428                         raoffset = (off_t)rabn * biosize;
429                         if (findblk(vp, raoffset, FINDBLK_TEST) == NULL) {
430                             rabp = nfs_getcacheblk(vp, raoffset, biosize, td);
431                             if (!rabp)
432                                 return (EINTR);
433                             if ((rabp->b_flags & (B_CACHE|B_DELWRI)) == 0) {
434                                 rabp->b_cmd = BUF_CMD_READ;
435                                 vfs_busy_pages(vp, rabp);
436                                 if (nfs_asyncio(vp, &rabp->b_bio2, td)) {
437                                     rabp->b_flags |= B_INVAL|B_ERROR;
438                                     vfs_unbusy_pages(rabp);
439                                     brelse(rabp);
440                                     break;
441                                 }
442                             } else {
443                                 brelse(rabp);
444                             }
445                         }
446                     }
447                 }
448
449                 /*
450                  * Obtain the buffer cache block.  Figure out the buffer size
451                  * when we are at EOF.  If we are modifying the size of the
452                  * buffer based on an EOF condition we need to hold 
453                  * nfs_rslock() through obtaining the buffer to prevent
454                  * a potential writer-appender from messing with n_size.
455                  * Otherwise we may accidently truncate the buffer and
456                  * lose dirty data.
457                  *
458                  * Note that bcount is *not* DEV_BSIZE aligned.
459                  */
460
461 again:
462                 bcount = biosize;
463                 if (loffset >= np->n_size) {
464                         bcount = 0;
465                 } else if (loffset + biosize > np->n_size) {
466                         bcount = np->n_size - loffset;
467                 }
468                 if (bcount != biosize) {
469                         switch(nfs_rslock(np)) {
470                         case ENOLCK:
471                                 goto again;
472                                 /* not reached */
473                         case EINTR:
474                         case ERESTART:
475                                 return(EINTR);
476                                 /* not reached */
477                         default:
478                                 break;
479                         }
480                 }
481
482                 bp = nfs_getcacheblk(vp, loffset, bcount, td);
483
484                 if (bcount != biosize)
485                         nfs_rsunlock(np);
486                 if (!bp)
487                         return (EINTR);
488
489                 /*
490                  * If B_CACHE is not set, we must issue the read.  If this
491                  * fails, we return an error.
492                  */
493
494                 if ((bp->b_flags & B_CACHE) == 0) {
495                     bp->b_cmd = BUF_CMD_READ;
496                     bp->b_bio2.bio_done = nfsiodone_sync;
497                     bp->b_bio2.bio_flags |= BIO_SYNC;
498                     vfs_busy_pages(vp, bp);
499                     error = nfs_doio(vp, &bp->b_bio2, td);
500                     if (error) {
501                         brelse(bp);
502                         return (error);
503                     }
504                 }
505
506                 /*
507                  * on is the offset into the current bp.  Figure out how many
508                  * bytes we can copy out of the bp.  Note that bcount is
509                  * NOT DEV_BSIZE aligned.
510                  *
511                  * Then figure out how many bytes we can copy into the uio.
512                  */
513
514                 n = 0;
515                 if (on < bcount)
516                         n = min((unsigned)(bcount - on), uio->uio_resid);
517                 break;
518             case VLNK:
519                 biosize = min(NFS_MAXPATHLEN, np->n_size);
520                 nfsstats.biocache_readlinks++;
521                 bp = nfs_getcacheblk(vp, (off_t)0, biosize, td);
522                 if (bp == NULL)
523                         return (EINTR);
524                 if ((bp->b_flags & B_CACHE) == 0) {
525                     bp->b_cmd = BUF_CMD_READ;
526                     bp->b_bio2.bio_done = nfsiodone_sync;
527                     bp->b_bio2.bio_flags |= BIO_SYNC;
528                     vfs_busy_pages(vp, bp);
529                     error = nfs_doio(vp, &bp->b_bio2, td);
530                     if (error) {
531                         bp->b_flags |= B_ERROR | B_INVAL;
532                         brelse(bp);
533                         return (error);
534                     }
535                 }
536                 n = min(uio->uio_resid, bp->b_bcount - bp->b_resid);
537                 on = 0;
538                 break;
539             case VDIR:
540                 nfsstats.biocache_readdirs++;
541                 if (np->n_direofoffset
542                     && uio->uio_offset >= np->n_direofoffset) {
543                     return (0);
544                 }
545                 lbn = (uoff_t)uio->uio_offset / NFS_DIRBLKSIZ;
546                 on = uio->uio_offset & (NFS_DIRBLKSIZ - 1);
547                 loffset = uio->uio_offset - on;
548                 bp = nfs_getcacheblk(vp, loffset, NFS_DIRBLKSIZ, td);
549                 if (bp == NULL)
550                     return (EINTR);
551
552                 if ((bp->b_flags & B_CACHE) == 0) {
553                     bp->b_cmd = BUF_CMD_READ;
554                     bp->b_bio2.bio_done = nfsiodone_sync;
555                     bp->b_bio2.bio_flags |= BIO_SYNC;
556                     vfs_busy_pages(vp, bp);
557                     error = nfs_doio(vp, &bp->b_bio2, td);
558                     if (error) {
559                             brelse(bp);
560                     }
561                     while (error == NFSERR_BAD_COOKIE) {
562                         kprintf("got bad cookie vp %p bp %p\n", vp, bp);
563                         nfs_invaldir(vp);
564                         error = nfs_vinvalbuf(vp, 0, 1);
565                         /*
566                          * Yuck! The directory has been modified on the
567                          * server. The only way to get the block is by
568                          * reading from the beginning to get all the
569                          * offset cookies.
570                          *
571                          * Leave the last bp intact unless there is an error.
572                          * Loop back up to the while if the error is another
573                          * NFSERR_BAD_COOKIE (double yuch!).
574                          */
575                         for (i = 0; i <= lbn && !error; i++) {
576                             if (np->n_direofoffset
577                                 && (i * NFS_DIRBLKSIZ) >= np->n_direofoffset)
578                                     return (0);
579                             bp = nfs_getcacheblk(vp, (off_t)i * NFS_DIRBLKSIZ,
580                                                  NFS_DIRBLKSIZ, td);
581                             if (!bp)
582                                 return (EINTR);
583                             if ((bp->b_flags & B_CACHE) == 0) {
584                                     bp->b_cmd = BUF_CMD_READ;
585                                     bp->b_bio2.bio_done = nfsiodone_sync;
586                                     bp->b_bio2.bio_flags |= BIO_SYNC;
587                                     vfs_busy_pages(vp, bp);
588                                     error = nfs_doio(vp, &bp->b_bio2, td);
589                                     /*
590                                      * no error + B_INVAL == directory EOF,
591                                      * use the block.
592                                      */
593                                     if (error == 0 && (bp->b_flags & B_INVAL))
594                                             break;
595                             }
596                             /*
597                              * An error will throw away the block and the
598                              * for loop will break out.  If no error and this
599                              * is not the block we want, we throw away the
600                              * block and go for the next one via the for loop.
601                              */
602                             if (error || i < lbn)
603                                     brelse(bp);
604                         }
605                     }
606                     /*
607                      * The above while is repeated if we hit another cookie
608                      * error.  If we hit an error and it wasn't a cookie error,
609                      * we give up.
610                      */
611                     if (error)
612                             return (error);
613                 }
614
615                 /*
616                  * If not eof and read aheads are enabled, start one.
617                  * (You need the current block first, so that you have the
618                  *  directory offset cookie of the next block.)
619                  */
620                 if (nmp->nm_readahead > 0 &&
621                     (bp->b_flags & B_INVAL) == 0 &&
622                     (np->n_direofoffset == 0 ||
623                     loffset + NFS_DIRBLKSIZ < np->n_direofoffset) &&
624                     (np->n_flag & NDONTCACHE) == 0 &&
625                     findblk(vp, loffset + NFS_DIRBLKSIZ, FINDBLK_TEST) == NULL
626                 ) {
627                         rabp = nfs_getcacheblk(vp, loffset + NFS_DIRBLKSIZ,
628                                                NFS_DIRBLKSIZ, td);
629                         if (rabp) {
630                             if ((rabp->b_flags & (B_CACHE|B_DELWRI)) == 0) {
631                                 rabp->b_cmd = BUF_CMD_READ;
632                                 vfs_busy_pages(vp, rabp);
633                                 if (nfs_asyncio(vp, &rabp->b_bio2, td)) {
634                                     rabp->b_flags |= B_INVAL|B_ERROR;
635                                     vfs_unbusy_pages(rabp);
636                                     brelse(rabp);
637                                 }
638                             } else {
639                                 brelse(rabp);
640                             }
641                         }
642                 }
643                 /*
644                  * Unlike VREG files, whos buffer size ( bp->b_bcount ) is
645                  * chopped for the EOF condition, we cannot tell how large
646                  * NFS directories are going to be until we hit EOF.  So
647                  * an NFS directory buffer is *not* chopped to its EOF.  Now,
648                  * it just so happens that b_resid will effectively chop it
649                  * to EOF.  *BUT* this information is lost if the buffer goes
650                  * away and is reconstituted into a B_CACHE state ( due to
651                  * being VMIO ) later.  So we keep track of the directory eof
652                  * in np->n_direofoffset and chop it off as an extra step 
653                  * right here.
654                  */
655                 n = lmin(uio->uio_resid, NFS_DIRBLKSIZ - bp->b_resid - on);
656                 if (np->n_direofoffset && n > np->n_direofoffset - uio->uio_offset)
657                         n = np->n_direofoffset - uio->uio_offset;
658                 break;
659             default:
660                 kprintf(" nfs_bioread: type %x unexpected\n",vp->v_type);
661                 break;
662             };
663
664             switch (vp->v_type) {
665             case VREG:
666                 if (n > 0)
667                     error = uiomove(bp->b_data + on, (int)n, uio);
668                 break;
669             case VLNK:
670                 if (n > 0)
671                     error = uiomove(bp->b_data + on, (int)n, uio);
672                 n = 0;
673                 break;
674             case VDIR:
675                 if (n > 0) {
676                     off_t old_off = uio->uio_offset;
677                     caddr_t cpos, epos;
678                     struct nfs_dirent *dp;
679
680                     /*
681                      * We are casting cpos to nfs_dirent, it must be
682                      * int-aligned.
683                      */
684                     if (on & 3) {
685                         error = EINVAL;
686                         break;
687                     }
688
689                     cpos = bp->b_data + on;
690                     epos = bp->b_data + on + n;
691                     while (cpos < epos && error == 0 && uio->uio_resid > 0) {
692                             dp = (struct nfs_dirent *)cpos;
693                             error = nfs_check_dirent(dp, (int)(epos - cpos));
694                             if (error)
695                                     break;
696                             if (vop_write_dirent(&error, uio, dp->nfs_ino,
697                                 dp->nfs_type, dp->nfs_namlen, dp->nfs_name)) {
698                                     break;
699                             }
700                             cpos += dp->nfs_reclen;
701                     }
702                     n = 0;
703                     if (error == 0)
704                             uio->uio_offset = old_off + cpos - bp->b_data - on;
705                 }
706                 /*
707                  * Invalidate buffer if caching is disabled, forcing a
708                  * re-read from the remote later.
709                  */
710                 if (np->n_flag & NDONTCACHE)
711                         bp->b_flags |= B_INVAL;
712                 break;
713             default:
714                 kprintf(" nfs_bioread: type %x unexpected\n",vp->v_type);
715             }
716             brelse(bp);
717         } while (error == 0 && uio->uio_resid > 0 && n > 0);
718         return (error);
719 }
720
721 /*
722  * Userland can supply any 'seek' offset when reading a NFS directory.
723  * Validate the structure so we don't panic the kernel.  Note that
724  * the element name is nul terminated and the nul is not included
725  * in nfs_namlen.
726  */
727 static
728 int
729 nfs_check_dirent(struct nfs_dirent *dp, int maxlen)
730 {
731         int nfs_name_off = offsetof(struct nfs_dirent, nfs_name[0]);
732
733         if (nfs_name_off >= maxlen)
734                 return (EINVAL);
735         if (dp->nfs_reclen < nfs_name_off || dp->nfs_reclen > maxlen)
736                 return (EINVAL);
737         if (nfs_name_off + dp->nfs_namlen >= dp->nfs_reclen)
738                 return (EINVAL);
739         if (dp->nfs_reclen & 3)
740                 return (EINVAL);
741         return (0);
742 }
743
744 /*
745  * Vnode op for write using bio
746  *
747  * nfs_write(struct vnode *a_vp, struct uio *a_uio, int a_ioflag,
748  *           struct ucred *a_cred)
749  */
750 int
751 nfs_write(struct vop_write_args *ap)
752 {
753         struct uio *uio = ap->a_uio;
754         struct thread *td = uio->uio_td;
755         struct vnode *vp = ap->a_vp;
756         struct nfsnode *np = VTONFS(vp);
757         int ioflag = ap->a_ioflag;
758         struct buf *bp;
759         struct vattr vattr;
760         struct nfsmount *nmp = VFSTONFS(vp->v_mount);
761         daddr_t lbn;
762         off_t loffset;
763         int n, on, error = 0, iomode, must_commit;
764         int haverslock = 0;
765         int bcount;
766         int biosize;
767
768 #ifdef DIAGNOSTIC
769         if (uio->uio_rw != UIO_WRITE)
770                 panic("nfs_write mode");
771         if (uio->uio_segflg == UIO_USERSPACE && uio->uio_td != curthread)
772                 panic("nfs_write proc");
773 #endif
774         if (vp->v_type != VREG)
775                 return (EIO);
776         if (np->n_flag & NWRITEERR) {
777                 np->n_flag &= ~NWRITEERR;
778                 return (np->n_error);
779         }
780         if ((nmp->nm_flag & NFSMNT_NFSV3) != 0 &&
781             (nmp->nm_state & NFSSTA_GOTFSINFO) == 0)
782                 (void)nfs_fsinfo(nmp, vp, td);
783
784         /*
785          * Synchronously flush pending buffers if we are in synchronous
786          * mode or if we are appending.
787          */
788         if (ioflag & (IO_APPEND | IO_SYNC)) {
789                 if (np->n_flag & NLMODIFIED) {
790                         np->n_attrstamp = 0;
791                         error = nfs_flush(vp, MNT_WAIT, td, 0);
792                         /* error = nfs_vinvalbuf(vp, V_SAVE, 1); */
793                         if (error)
794                                 return (error);
795                 }
796         }
797
798         /*
799          * If IO_APPEND then load uio_offset.  We restart here if we cannot
800          * get the append lock.
801          */
802 restart:
803         if (ioflag & IO_APPEND) {
804                 np->n_attrstamp = 0;
805                 error = VOP_GETATTR(vp, &vattr);
806                 if (error)
807                         return (error);
808                 uio->uio_offset = np->n_size;
809         }
810
811         if (uio->uio_offset < 0)
812                 return (EINVAL);
813         if ((uio->uio_offset + uio->uio_resid) > nmp->nm_maxfilesize)
814                 return (EFBIG);
815         if (uio->uio_resid == 0)
816                 return (0);
817
818         /*
819          * We need to obtain the rslock if we intend to modify np->n_size
820          * in order to guarentee the append point with multiple contending
821          * writers, to guarentee that no other appenders modify n_size
822          * while we are trying to obtain a truncated buffer (i.e. to avoid
823          * accidently truncating data written by another appender due to
824          * the race), and to ensure that the buffer is populated prior to
825          * our extending of the file.  We hold rslock through the entire
826          * operation.
827          *
828          * Note that we do not synchronize the case where someone truncates
829          * the file while we are appending to it because attempting to lock
830          * this case may deadlock other parts of the system unexpectedly.
831          */
832         if ((ioflag & IO_APPEND) ||
833             uio->uio_offset + uio->uio_resid > np->n_size) {
834                 switch(nfs_rslock(np)) {
835                 case ENOLCK:
836                         goto restart;
837                         /* not reached */
838                 case EINTR:
839                 case ERESTART:
840                         return(EINTR);
841                         /* not reached */
842                 default:
843                         break;
844                 }
845                 haverslock = 1;
846         }
847
848         /*
849          * Maybe this should be above the vnode op call, but so long as
850          * file servers have no limits, i don't think it matters
851          */
852         if (td->td_proc && uio->uio_offset + uio->uio_resid >
853               td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur) {
854                 lwpsignal(td->td_proc, td->td_lwp, SIGXFSZ);
855                 if (haverslock)
856                         nfs_rsunlock(np);
857                 return (EFBIG);
858         }
859
860         biosize = vp->v_mount->mnt_stat.f_iosize;
861
862         do {
863                 if ((np->n_flag & NDONTCACHE) && uio->uio_iovcnt == 1) {
864                     iomode = NFSV3WRITE_FILESYNC;
865                     error = nfs_writerpc(vp, uio, &iomode, &must_commit);
866                     if (must_commit)
867                             nfs_clearcommit(vp->v_mount);
868                     break;
869                 }
870                 nfsstats.biocache_writes++;
871                 lbn = uio->uio_offset / biosize;
872                 on = uio->uio_offset & (biosize-1);
873                 loffset = uio->uio_offset - on;
874                 n = min((unsigned)(biosize - on), uio->uio_resid);
875 again:
876                 /*
877                  * Handle direct append and file extension cases, calculate
878                  * unaligned buffer size.
879                  */
880
881                 if (uio->uio_offset == np->n_size && n) {
882                         /*
883                          * Get the buffer (in its pre-append state to maintain
884                          * B_CACHE if it was previously set).  Resize the
885                          * nfsnode after we have locked the buffer to prevent
886                          * readers from reading garbage.
887                          */
888                         bcount = on;
889                         bp = nfs_getcacheblk(vp, loffset, bcount, td);
890
891                         if (bp != NULL) {
892                                 long save;
893
894                                 np->n_size = uio->uio_offset + n;
895                                 np->n_flag |= NLMODIFIED;
896                                 vnode_pager_setsize(vp, np->n_size);
897
898                                 save = bp->b_flags & B_CACHE;
899                                 bcount += n;
900                                 allocbuf(bp, bcount);
901                                 bp->b_flags |= save;
902                         }
903                 } else {
904                         /*
905                          * Obtain the locked cache block first, and then 
906                          * adjust the file's size as appropriate.
907                          */
908                         bcount = on + n;
909                         if (loffset + bcount < np->n_size) {
910                                 if (loffset + biosize < np->n_size)
911                                         bcount = biosize;
912                                 else
913                                         bcount = np->n_size - loffset;
914                         }
915                         bp = nfs_getcacheblk(vp, loffset, bcount, td);
916                         if (uio->uio_offset + n > np->n_size) {
917                                 np->n_size = uio->uio_offset + n;
918                                 np->n_flag |= NLMODIFIED;
919                                 vnode_pager_setsize(vp, np->n_size);
920                         }
921                 }
922
923                 if (bp == NULL) {
924                         error = EINTR;
925                         break;
926                 }
927
928                 /*
929                  * Issue a READ if B_CACHE is not set.  In special-append
930                  * mode, B_CACHE is based on the buffer prior to the write
931                  * op and is typically set, avoiding the read.  If a read
932                  * is required in special append mode, the server will
933                  * probably send us a short-read since we extended the file
934                  * on our end, resulting in b_resid == 0 and, thusly, 
935                  * B_CACHE getting set.
936                  *
937                  * We can also avoid issuing the read if the write covers
938                  * the entire buffer.  We have to make sure the buffer state
939                  * is reasonable in this case since we will not be initiating
940                  * I/O.  See the comments in kern/vfs_bio.c's getblk() for
941                  * more information.
942                  *
943                  * B_CACHE may also be set due to the buffer being cached
944                  * normally.
945                  *
946                  * When doing a UIO_NOCOPY write the buffer is not
947                  * overwritten and we cannot just set B_CACHE unconditionally
948                  * for full-block writes.
949                  */
950
951                 if (on == 0 && n == bcount && uio->uio_segflg != UIO_NOCOPY) {
952                         bp->b_flags |= B_CACHE;
953                         bp->b_flags &= ~(B_ERROR | B_INVAL);
954                 }
955
956                 if ((bp->b_flags & B_CACHE) == 0) {
957                         bp->b_cmd = BUF_CMD_READ;
958                         bp->b_bio2.bio_done = nfsiodone_sync;
959                         bp->b_bio2.bio_flags |= BIO_SYNC;
960                         vfs_busy_pages(vp, bp);
961                         error = nfs_doio(vp, &bp->b_bio2, td);
962                         if (error) {
963                                 brelse(bp);
964                                 break;
965                         }
966                 }
967                 if (!bp) {
968                         error = EINTR;
969                         break;
970                 }
971                 np->n_flag |= NLMODIFIED;
972
973                 /*
974                  * If dirtyend exceeds file size, chop it down.  This should
975                  * not normally occur but there is an append race where it
976                  * might occur XXX, so we log it. 
977                  *
978                  * If the chopping creates a reverse-indexed or degenerate
979                  * situation with dirtyoff/end, we 0 both of them.
980                  */
981
982                 if (bp->b_dirtyend > bcount) {
983                         kprintf("NFS append race @%08llx:%d\n", 
984                             (long long)bp->b_bio2.bio_offset,
985                             bp->b_dirtyend - bcount);
986                         bp->b_dirtyend = bcount;
987                 }
988
989                 if (bp->b_dirtyoff >= bp->b_dirtyend)
990                         bp->b_dirtyoff = bp->b_dirtyend = 0;
991
992                 /*
993                  * If the new write will leave a contiguous dirty
994                  * area, just update the b_dirtyoff and b_dirtyend,
995                  * otherwise force a write rpc of the old dirty area.
996                  *
997                  * While it is possible to merge discontiguous writes due to 
998                  * our having a B_CACHE buffer ( and thus valid read data
999                  * for the hole), we don't because it could lead to 
1000                  * significant cache coherency problems with multiple clients,
1001                  * especially if locking is implemented later on.
1002                  *
1003                  * as an optimization we could theoretically maintain
1004                  * a linked list of discontinuous areas, but we would still
1005                  * have to commit them separately so there isn't much
1006                  * advantage to it except perhaps a bit of asynchronization.
1007                  */
1008
1009                 if (bp->b_dirtyend > 0 &&
1010                     (on > bp->b_dirtyend || (on + n) < bp->b_dirtyoff)) {
1011                         if (bwrite(bp) == EINTR) {
1012                                 error = EINTR;
1013                                 break;
1014                         }
1015                         goto again;
1016                 }
1017
1018                 error = uiomove((char *)bp->b_data + on, n, uio);
1019
1020                 /*
1021                  * Since this block is being modified, it must be written
1022                  * again and not just committed.  Since write clustering does
1023                  * not work for the stage 1 data write, only the stage 2
1024                  * commit rpc, we have to clear B_CLUSTEROK as well.
1025                  */
1026                 bp->b_flags &= ~(B_NEEDCOMMIT | B_CLUSTEROK);
1027
1028                 if (error) {
1029                         bp->b_flags |= B_ERROR;
1030                         brelse(bp);
1031                         break;
1032                 }
1033
1034                 /*
1035                  * Only update dirtyoff/dirtyend if not a degenerate 
1036                  * condition.
1037                  */
1038                 if (n) {
1039                         if (bp->b_dirtyend > 0) {
1040                                 bp->b_dirtyoff = min(on, bp->b_dirtyoff);
1041                                 bp->b_dirtyend = max((on + n), bp->b_dirtyend);
1042                         } else {
1043                                 bp->b_dirtyoff = on;
1044                                 bp->b_dirtyend = on + n;
1045                         }
1046                         vfs_bio_set_validclean(bp, on, n);
1047                 }
1048
1049                 /*
1050                  * If the lease is non-cachable or IO_SYNC do bwrite().
1051                  *
1052                  * IO_INVAL appears to be unused.  The idea appears to be
1053                  * to turn off caching in this case.  Very odd.  XXX
1054                  *
1055                  * If nfs_async is set bawrite() will use an unstable write
1056                  * (build dirty bufs on the server), so we might as well
1057                  * push it out with bawrite().  If nfs_async is not set we
1058                  * use bdwrite() to cache dirty bufs on the client.
1059                  */
1060                 if ((np->n_flag & NDONTCACHE) || (ioflag & IO_SYNC)) {
1061                         if (ioflag & IO_INVAL)
1062                                 bp->b_flags |= B_NOCACHE;
1063                         error = bwrite(bp);
1064                         if (error)
1065                                 break;
1066                         if (np->n_flag & NDONTCACHE) {
1067                                 error = nfs_vinvalbuf(vp, V_SAVE, 1);
1068                                 if (error)
1069                                         break;
1070                         }
1071                 } else if ((n + on) == biosize && nfs_async) {
1072                         bawrite(bp);
1073                 } else {
1074                         bdwrite(bp);
1075                 }
1076         } while (uio->uio_resid > 0 && n > 0);
1077
1078         if (haverslock)
1079                 nfs_rsunlock(np);
1080
1081         return (error);
1082 }
1083
1084 /*
1085  * Get an nfs cache block.
1086  *
1087  * Allocate a new one if the block isn't currently in the cache
1088  * and return the block marked busy. If the calling process is
1089  * interrupted by a signal for an interruptible mount point, return
1090  * NULL.
1091  *
1092  * The caller must carefully deal with the possible B_INVAL state of
1093  * the buffer.  nfs_doio() clears B_INVAL (and nfs_asyncio() clears it
1094  * indirectly), so synchronous reads can be issued without worrying about
1095  * the B_INVAL state.  We have to be a little more careful when dealing
1096  * with writes (see comments in nfs_write()) when extending a file past
1097  * its EOF.
1098  */
1099 static struct buf *
1100 nfs_getcacheblk(struct vnode *vp, off_t loffset, int size, struct thread *td)
1101 {
1102         struct buf *bp;
1103         struct mount *mp;
1104         struct nfsmount *nmp;
1105
1106         mp = vp->v_mount;
1107         nmp = VFSTONFS(mp);
1108
1109         if (nmp->nm_flag & NFSMNT_INT) {
1110                 bp = getblk(vp, loffset, size, GETBLK_PCATCH, 0);
1111                 while (bp == NULL) {
1112                         if (nfs_sigintr(nmp, NULL, td))
1113                                 return (NULL);
1114                         bp = getblk(vp, loffset, size, 0, 2 * hz);
1115                 }
1116         } else {
1117                 bp = getblk(vp, loffset, size, 0, 0);
1118         }
1119
1120         /*
1121          * bio2, the 'device' layer.  Since BIOs use 64 bit byte offsets
1122          * now, no translation is necessary.
1123          */
1124         bp->b_bio2.bio_offset = loffset;
1125         return (bp);
1126 }
1127
1128 /*
1129  * Flush and invalidate all dirty buffers. If another process is already
1130  * doing the flush, just wait for completion.
1131  */
1132 int
1133 nfs_vinvalbuf(struct vnode *vp, int flags, int intrflg)
1134 {
1135         struct nfsnode *np = VTONFS(vp);
1136         struct nfsmount *nmp = VFSTONFS(vp->v_mount);
1137         int error = 0, slpflag, slptimeo;
1138         thread_t td = curthread;
1139
1140         if (vp->v_flag & VRECLAIMED)
1141                 return (0);
1142
1143         if ((nmp->nm_flag & NFSMNT_INT) == 0)
1144                 intrflg = 0;
1145         if (intrflg) {
1146                 slpflag = PCATCH;
1147                 slptimeo = 2 * hz;
1148         } else {
1149                 slpflag = 0;
1150                 slptimeo = 0;
1151         }
1152         /*
1153          * First wait for any other process doing a flush to complete.
1154          */
1155         while (np->n_flag & NFLUSHINPROG) {
1156                 np->n_flag |= NFLUSHWANT;
1157                 error = tsleep((caddr_t)&np->n_flag, 0, "nfsvinval", slptimeo);
1158                 if (error && intrflg && nfs_sigintr(nmp, NULL, td))
1159                         return (EINTR);
1160         }
1161
1162         /*
1163          * Now, flush as required.
1164          */
1165         np->n_flag |= NFLUSHINPROG;
1166         error = vinvalbuf(vp, flags, slpflag, 0);
1167         while (error) {
1168                 if (intrflg && nfs_sigintr(nmp, NULL, td)) {
1169                         np->n_flag &= ~NFLUSHINPROG;
1170                         if (np->n_flag & NFLUSHWANT) {
1171                                 np->n_flag &= ~NFLUSHWANT;
1172                                 wakeup((caddr_t)&np->n_flag);
1173                         }
1174                         return (EINTR);
1175                 }
1176                 error = vinvalbuf(vp, flags, 0, slptimeo);
1177         }
1178         np->n_flag &= ~(NLMODIFIED | NFLUSHINPROG);
1179         if (np->n_flag & NFLUSHWANT) {
1180                 np->n_flag &= ~NFLUSHWANT;
1181                 wakeup((caddr_t)&np->n_flag);
1182         }
1183         return (0);
1184 }
1185
1186 /*
1187  * Initiate asynchronous I/O. Return an error if no nfsiods are available.
1188  * This is mainly to avoid queueing async I/O requests when the nfsiods
1189  * are all hung on a dead server.
1190  *
1191  * Note: nfs_asyncio() does not clear (B_ERROR|B_INVAL) but when the bp
1192  * is eventually dequeued by the async daemon, nfs_doio() *will*.
1193  */
1194 int
1195 nfs_asyncio(struct vnode *vp, struct bio *bio, struct thread *td)
1196 {
1197         struct buf *bp = bio->bio_buf;
1198         struct nfsmount *nmp;
1199
1200         KKASSERT(vp->v_tag == VT_NFS);
1201         nmp = VFSTONFS(vp->v_mount);
1202
1203         /*
1204          * If no async daemons then return EIO to force caller to run the rpc
1205          * synchronously.
1206          */
1207         if (nmp->nm_rxstate > NFSSVC_PENDING)
1208                 return (EIO);
1209
1210         BUF_KERNPROC(bp);
1211
1212         /*
1213          * The passed bio's buffer is not necessary associated with
1214          * the NFS vnode it is being written to.  Store the NFS vnode
1215          * in the BIO driver info.
1216          */
1217         bio->bio_driver_info = vp;
1218         TAILQ_INSERT_TAIL(&nmp->nm_bioq, bio, bio_act);
1219         nmp->nm_bioqlen++;
1220         nfssvc_iod_writer_wakeup(nmp);
1221         return (0);
1222 }
1223
1224 /*
1225  * Do an I/O operation to/from a cache block. This may be called
1226  * synchronously or from an nfsiod.  The BIO is normalized for DEV_BSIZE.
1227  *
1228  * A locked, completed I/O is returned and the caller is responsible for
1229  * brelse()'ing it.
1230  *
1231  * NOTE! TD MIGHT BE NULL
1232  */
1233 int
1234 nfs_doio(struct vnode *vp, struct bio *bio, struct thread *td)
1235 {
1236         struct buf *bp = bio->bio_buf;
1237         struct uio *uiop;
1238         struct nfsnode *np;
1239         struct nfsmount *nmp;
1240         int error = 0, iomode, must_commit = 0;
1241         struct uio uio;
1242         struct iovec io;
1243
1244         KKASSERT(vp->v_tag == VT_NFS);
1245         np = VTONFS(vp);
1246         nmp = VFSTONFS(vp->v_mount);
1247         uiop = &uio;
1248         uiop->uio_iov = &io;
1249         uiop->uio_iovcnt = 1;
1250         uiop->uio_segflg = UIO_SYSSPACE;
1251         uiop->uio_td = td;
1252
1253         /*
1254          * clear B_ERROR and B_INVAL state prior to initiating the I/O.  We
1255          * do this here so we do not have to do it in all the code that
1256          * calls us.
1257          */
1258         bp->b_flags &= ~(B_ERROR | B_INVAL);
1259
1260
1261         KASSERT(bp->b_cmd != BUF_CMD_DONE, 
1262                 ("nfs_doio: bp %p already marked done!", bp));
1263
1264         if (bp->b_cmd == BUF_CMD_READ) {
1265             io.iov_len = uiop->uio_resid = bp->b_bcount;
1266             io.iov_base = bp->b_data;
1267             uiop->uio_rw = UIO_READ;
1268
1269             switch (vp->v_type) {
1270             case VREG:
1271                 uiop->uio_offset = bio->bio_offset;
1272                 nfsstats.read_bios++;
1273                 error = nfs_readrpc(vp, uiop);
1274
1275                 if (!error) {
1276                     if (uiop->uio_resid) {
1277                         /*
1278                          * If we had a short read with no error, we must have
1279                          * hit a file hole.  We should zero-fill the remainder.
1280                          * This can also occur if the server hits the file EOF.
1281                          *
1282                          * Holes used to be able to occur due to pending 
1283                          * writes, but that is not possible any longer.
1284                          */
1285                         int nread = bp->b_bcount - uiop->uio_resid;
1286                         int left  = uiop->uio_resid;
1287
1288                         if (left > 0)
1289                                 bzero((char *)bp->b_data + nread, left);
1290                         uiop->uio_resid = 0;
1291                     }
1292                 }
1293                 if (td && td->td_proc && (vp->v_flag & VTEXT) &&
1294                     np->n_mtime != np->n_vattr.va_mtime.tv_sec) {
1295                         uprintf("Process killed due to text file modification\n");
1296                         ksignal(td->td_proc, SIGKILL);
1297                 }
1298                 break;
1299             case VLNK:
1300                 uiop->uio_offset = 0;
1301                 nfsstats.readlink_bios++;
1302                 error = nfs_readlinkrpc(vp, uiop);
1303                 break;
1304             case VDIR:
1305                 nfsstats.readdir_bios++;
1306                 uiop->uio_offset = bio->bio_offset;
1307                 if (nmp->nm_flag & NFSMNT_RDIRPLUS) {
1308                         error = nfs_readdirplusrpc(vp, uiop);
1309                         if (error == NFSERR_NOTSUPP)
1310                                 nmp->nm_flag &= ~NFSMNT_RDIRPLUS;
1311                 }
1312                 if ((nmp->nm_flag & NFSMNT_RDIRPLUS) == 0)
1313                         error = nfs_readdirrpc(vp, uiop);
1314                 /*
1315                  * end-of-directory sets B_INVAL but does not generate an
1316                  * error.
1317                  */
1318                 if (error == 0 && uiop->uio_resid == bp->b_bcount)
1319                         bp->b_flags |= B_INVAL;
1320                 break;
1321             default:
1322                 kprintf("nfs_doio:  type %x unexpected\n",vp->v_type);
1323                 break;
1324             };
1325             if (error) {
1326                 bp->b_flags |= B_ERROR;
1327                 bp->b_error = error;
1328             }
1329         } else {
1330             /* 
1331              * If we only need to commit, try to commit
1332              */
1333             KKASSERT(bp->b_cmd == BUF_CMD_WRITE);
1334             if (bp->b_flags & B_NEEDCOMMIT) {
1335                     int retv;
1336                     off_t off;
1337
1338                     off = bio->bio_offset + bp->b_dirtyoff;
1339                     retv = nfs_commit(vp, off, 
1340                                 bp->b_dirtyend - bp->b_dirtyoff, td);
1341                     if (retv == 0) {
1342                             bp->b_dirtyoff = bp->b_dirtyend = 0;
1343                             bp->b_flags &= ~(B_NEEDCOMMIT | B_CLUSTEROK);
1344                             bp->b_resid = 0;
1345                             biodone(bio);
1346                             return (0);
1347                     }
1348                     if (retv == NFSERR_STALEWRITEVERF) {
1349                             nfs_clearcommit(vp->v_mount);
1350                     }
1351             }
1352
1353             /*
1354              * Setup for actual write
1355              */
1356
1357             if (bio->bio_offset + bp->b_dirtyend > np->n_size)
1358                 bp->b_dirtyend = np->n_size - bio->bio_offset;
1359
1360             if (bp->b_dirtyend > bp->b_dirtyoff) {
1361                 io.iov_len = uiop->uio_resid = bp->b_dirtyend
1362                     - bp->b_dirtyoff;
1363                 uiop->uio_offset = bio->bio_offset + bp->b_dirtyoff;
1364                 io.iov_base = (char *)bp->b_data + bp->b_dirtyoff;
1365                 uiop->uio_rw = UIO_WRITE;
1366                 nfsstats.write_bios++;
1367
1368                 if ((bp->b_flags & (B_NEEDCOMMIT | B_NOCACHE | B_CLUSTER)) == 0)
1369                     iomode = NFSV3WRITE_UNSTABLE;
1370                 else
1371                     iomode = NFSV3WRITE_FILESYNC;
1372
1373                 error = nfs_writerpc(vp, uiop, &iomode, &must_commit);
1374
1375                 /*
1376                  * When setting B_NEEDCOMMIT also set B_CLUSTEROK to try
1377                  * to cluster the buffers needing commit.  This will allow
1378                  * the system to submit a single commit rpc for the whole
1379                  * cluster.  We can do this even if the buffer is not 100% 
1380                  * dirty (relative to the NFS blocksize), so we optimize the
1381                  * append-to-file-case.
1382                  *
1383                  * (when clearing B_NEEDCOMMIT, B_CLUSTEROK must also be
1384                  * cleared because write clustering only works for commit
1385                  * rpc's, not for the data portion of the write).
1386                  */
1387
1388                 if (!error && iomode == NFSV3WRITE_UNSTABLE) {
1389                     bp->b_flags |= B_NEEDCOMMIT;
1390                     if (bp->b_dirtyoff == 0
1391                         && bp->b_dirtyend == bp->b_bcount)
1392                         bp->b_flags |= B_CLUSTEROK;
1393                 } else {
1394                     bp->b_flags &= ~(B_NEEDCOMMIT | B_CLUSTEROK);
1395                 }
1396
1397                 /*
1398                  * For an interrupted write, the buffer is still valid
1399                  * and the write hasn't been pushed to the server yet,
1400                  * so we can't set B_ERROR and report the interruption
1401                  * by setting B_EINTR. For the async case, B_EINTR
1402                  * is not relevant, so the rpc attempt is essentially
1403                  * a noop.  For the case of a V3 write rpc not being
1404                  * committed to stable storage, the block is still
1405                  * dirty and requires either a commit rpc or another
1406                  * write rpc with iomode == NFSV3WRITE_FILESYNC before
1407                  * the block is reused. This is indicated by setting
1408                  * the B_DELWRI and B_NEEDCOMMIT flags.
1409                  *
1410                  * If the buffer is marked B_PAGING, it does not reside on
1411                  * the vp's paging queues so we cannot call bdirty().  The
1412                  * bp in this case is not an NFS cache block so we should
1413                  * be safe. XXX
1414                  */
1415                 if (error == EINTR
1416                     || (!error && (bp->b_flags & B_NEEDCOMMIT))) {
1417                         crit_enter();
1418                         bp->b_flags &= ~(B_INVAL|B_NOCACHE);
1419                         if ((bp->b_flags & B_PAGING) == 0)
1420                             bdirty(bp);
1421                         if (error)
1422                             bp->b_flags |= B_EINTR;
1423                         crit_exit();
1424                 } else {
1425                     if (error) {
1426                         bp->b_flags |= B_ERROR;
1427                         bp->b_error = np->n_error = error;
1428                         np->n_flag |= NWRITEERR;
1429                     }
1430                     bp->b_dirtyoff = bp->b_dirtyend = 0;
1431                 }
1432             } else {
1433                 bp->b_resid = 0;
1434                 biodone(bio);
1435                 return (0);
1436             }
1437         }
1438         bp->b_resid = uiop->uio_resid;
1439         if (must_commit)
1440             nfs_clearcommit(vp->v_mount);
1441         biodone(bio);
1442         return (error);
1443 }
1444
1445 /*
1446  * Used to aid in handling ftruncate() operations on the NFS client side.
1447  * Truncation creates a number of special problems for NFS.  We have to
1448  * throw away VM pages and buffer cache buffers that are beyond EOF, and
1449  * we have to properly handle VM pages or (potentially dirty) buffers
1450  * that straddle the truncation point.
1451  */
1452
1453 int
1454 nfs_meta_setsize(struct vnode *vp, struct thread *td, u_quad_t nsize)
1455 {
1456         struct nfsnode *np = VTONFS(vp);
1457         u_quad_t tsize = np->n_size;
1458         int biosize = vp->v_mount->mnt_stat.f_iosize;
1459         int error = 0;
1460
1461         np->n_size = nsize;
1462
1463         if (np->n_size < tsize) {
1464                 struct buf *bp;
1465                 daddr_t lbn;
1466                 off_t loffset;
1467                 int bufsize;
1468
1469                 /*
1470                  * vtruncbuf() doesn't get the buffer overlapping the 
1471                  * truncation point.  We may have a B_DELWRI and/or B_CACHE
1472                  * buffer that now needs to be truncated.
1473                  */
1474                 error = vtruncbuf(vp, nsize, biosize);
1475                 lbn = nsize / biosize;
1476                 bufsize = nsize & (biosize - 1);
1477                 loffset = nsize - bufsize;
1478                 bp = nfs_getcacheblk(vp, loffset, bufsize, td);
1479                 if (bp->b_dirtyoff > bp->b_bcount)
1480                         bp->b_dirtyoff = bp->b_bcount;
1481                 if (bp->b_dirtyend > bp->b_bcount)
1482                         bp->b_dirtyend = bp->b_bcount;
1483                 bp->b_flags |= B_RELBUF;  /* don't leave garbage around */
1484                 brelse(bp);
1485         } else {
1486                 vnode_pager_setsize(vp, nsize);
1487         }
1488         return(error);
1489 }
1490
1491 /*
1492  * Synchronous completion for nfs_doio.  Call bpdone() with elseit=FALSE.
1493  * Caller is responsible for brelse()'ing the bp.
1494  */
1495 static void
1496 nfsiodone_sync(struct bio *bio)
1497 {
1498         bio->bio_flags = 0;
1499         bpdone(bio->bio_buf, 0);
1500 }