2 * Copyright (c) 1989, 1993
3 * The Regents of the University of California. All rights reserved.
5 * This code is derived from software contributed to Berkeley by
6 * Rick Macklem at The University of Guelph.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
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.
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
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.27 2006/03/05 18:38:37 dillon Exp $
42 #include <sys/param.h>
43 #include <sys/systm.h>
44 #include <sys/resourcevar.h>
45 #include <sys/signalvar.h>
48 #include <sys/vnode.h>
49 #include <sys/mount.h>
50 #include <sys/kernel.h>
52 #include <sys/msfbuf.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>
61 #include <sys/thread2.h>
70 static struct buf
*nfs_getcacheblk (struct vnode
*vp
, daddr_t bn
, int size
,
73 extern int nfs_numasync
;
74 extern int nfs_pbuf_freecnt
;
75 extern struct nfsstats nfsstats
;
78 * Vnode op for VM getpages.
80 * nfs_getpages(struct vnode *a_vp, vm_page_t *a_m, int a_count,
81 * int a_reqpage, vm_ooffset_t a_offset)
84 nfs_getpages(struct vop_getpages_args
*ap
)
86 struct thread
*td
= curthread
; /* XXX */
87 int i
, error
, nextoff
, size
, toff
, count
, npages
;
98 nmp
= VFSTONFS(vp
->v_mount
);
102 if (vp
->v_object
== NULL
) {
103 printf("nfs_getpages: called with non-merged cache vnode??\n");
104 return VM_PAGER_ERROR
;
107 if ((nmp
->nm_flag
& NFSMNT_NFSV3
) != 0 &&
108 (nmp
->nm_state
& NFSSTA_GOTFSINFO
) == 0)
109 (void)nfs_fsinfo(nmp
, vp
, td
);
111 npages
= btoc(count
);
114 * NOTE that partially valid pages may occur in cases other
115 * then file EOF, such as when a file is partially written and
116 * ftruncate()-extended to a larger size. It is also possible
117 * for the valid bits to be set on garbage beyond the file EOF and
118 * clear in the area before EOF (e.g. m->valid == 0xfc), which can
119 * occur due to vtruncbuf() and the buffer cache's handling of
120 * pages which 'straddle' buffers or when b_bufsize is not a
121 * multiple of PAGE_SIZE.... the buffer cache cannot normally
122 * clear the extra bits. This kind of situation occurs when you
123 * make a small write() (m->valid == 0x03) and then mmap() and
124 * fault in the buffer(m->valid = 0xFF). When NFS flushes the
125 * buffer (vinvalbuf() m->valid = 0xFC) we are left with a mess.
127 * This is combined with the possibility that the pages are partially
128 * dirty or that there is a buffer backing the pages that is dirty
129 * (even if m->dirty is 0).
131 * To solve this problem several hacks have been made: (1) NFS
132 * guarentees that the IO block size is a multiple of PAGE_SIZE and
133 * (2) The buffer cache, when invalidating an NFS buffer, will
134 * disregard the buffer's fragmentory b_bufsize and invalidate
135 * the whole page rather then just the piece the buffer owns.
137 * This allows us to assume that a partially valid page found here
138 * is fully valid (vm_fault will zero'd out areas of the page not
141 m
= pages
[ap
->a_reqpage
];
143 for (i
= 0; i
< npages
; ++i
) {
144 if (i
!= ap
->a_reqpage
)
145 vnode_pager_freepage(pages
[i
]);
151 * Use an MSF_BUF as a medium to retrieve data from the pages.
153 msf_map_pagelist(&msf
, pages
, npages
, 0);
155 kva
= msf_buf_kva(msf
);
161 uio
.uio_offset
= IDX_TO_OFF(pages
[0]->pindex
);
162 uio
.uio_resid
= count
;
163 uio
.uio_segflg
= UIO_SYSSPACE
;
164 uio
.uio_rw
= UIO_READ
;
167 error
= nfs_readrpc(vp
, &uio
);
170 if (error
&& (uio
.uio_resid
== count
)) {
171 printf("nfs_getpages: error %d\n", error
);
172 for (i
= 0; i
< npages
; ++i
) {
173 if (i
!= ap
->a_reqpage
)
174 vnode_pager_freepage(pages
[i
]);
176 return VM_PAGER_ERROR
;
180 * Calculate the number of bytes read and validate only that number
181 * of bytes. Note that due to pending writes, size may be 0. This
182 * does not mean that the remaining data is invalid!
185 size
= count
- uio
.uio_resid
;
187 for (i
= 0, toff
= 0; i
< npages
; i
++, toff
= nextoff
) {
188 nextoff
= toff
+ PAGE_SIZE
;
191 m
->flags
&= ~PG_ZERO
;
193 if (nextoff
<= size
) {
195 * Read operation filled an entire page
197 m
->valid
= VM_PAGE_BITS_ALL
;
199 } else if (size
> toff
) {
201 * Read operation filled a partial page.
204 vm_page_set_validclean(m
, 0, size
- toff
);
205 /* handled by vm_fault now */
206 /* vm_page_zero_invalid(m, TRUE); */
209 * Read operation was short. If no error occured
210 * we may have hit a zero-fill section. We simply
211 * leave valid set to 0.
215 if (i
!= ap
->a_reqpage
) {
217 * Whether or not to leave the page activated is up in
218 * the air, but we should put the page on a page queue
219 * somewhere (it already is in the object). Result:
220 * It appears that emperical results show that
221 * deactivating pages is best.
225 * Just in case someone was asking for this page we
226 * now tell them that it is ok to use.
229 if (m
->flags
& PG_WANTED
)
232 vm_page_deactivate(m
);
235 vnode_pager_freepage(m
);
243 * Vnode op for VM putpages.
245 * nfs_putpages(struct vnode *a_vp, vm_page_t *a_m, int a_count, int a_sync,
246 * int *a_rtvals, vm_ooffset_t a_offset)
249 nfs_putpages(struct vop_putpages_args
*ap
)
251 struct thread
*td
= curthread
;
255 int iomode
, must_commit
, i
, error
, npages
, count
;
259 struct nfsmount
*nmp
;
266 nmp
= VFSTONFS(vp
->v_mount
);
269 rtvals
= ap
->a_rtvals
;
270 npages
= btoc(count
);
271 offset
= IDX_TO_OFF(pages
[0]->pindex
);
273 if ((nmp
->nm_flag
& NFSMNT_NFSV3
) != 0 &&
274 (nmp
->nm_state
& NFSSTA_GOTFSINFO
) == 0)
275 (void)nfs_fsinfo(nmp
, vp
, td
);
277 for (i
= 0; i
< npages
; i
++) {
278 rtvals
[i
] = VM_PAGER_AGAIN
;
282 * When putting pages, do not extend file past EOF.
285 if (offset
+ count
> np
->n_size
) {
286 count
= np
->n_size
- offset
;
292 * Use an MSF_BUF as a medium to retrieve data from the pages.
294 msf_map_pagelist(&msf
, pages
, npages
, 0);
296 kva
= msf_buf_kva(msf
);
302 uio
.uio_offset
= offset
;
303 uio
.uio_resid
= count
;
304 uio
.uio_segflg
= UIO_SYSSPACE
;
305 uio
.uio_rw
= UIO_WRITE
;
308 if ((ap
->a_sync
& VM_PAGER_PUT_SYNC
) == 0)
309 iomode
= NFSV3WRITE_UNSTABLE
;
311 iomode
= NFSV3WRITE_FILESYNC
;
313 error
= nfs_writerpc(vp
, &uio
, &iomode
, &must_commit
);
318 int nwritten
= round_page(count
- uio
.uio_resid
) / PAGE_SIZE
;
319 for (i
= 0; i
< nwritten
; i
++) {
320 rtvals
[i
] = VM_PAGER_OK
;
321 vm_page_undirty(pages
[i
]);
324 nfs_clearcommit(vp
->v_mount
);
330 * Vnode op for read using bio
333 nfs_bioread(struct vnode
*vp
, struct uio
*uio
, int ioflag
)
335 struct nfsnode
*np
= VTONFS(vp
);
337 struct buf
*bp
= 0, *rabp
;
340 struct nfsmount
*nmp
= VFSTONFS(vp
->v_mount
);
344 int nra
, error
= 0, n
= 0, on
= 0;
347 if (uio
->uio_rw
!= UIO_READ
)
348 panic("nfs_read mode");
350 if (uio
->uio_resid
== 0)
352 if (uio
->uio_offset
< 0) /* XXX VDIR cookies can be negative */
356 if ((nmp
->nm_flag
& NFSMNT_NFSV3
) != 0 &&
357 (nmp
->nm_state
& NFSSTA_GOTFSINFO
) == 0)
358 (void)nfs_fsinfo(nmp
, vp
, td
);
359 if (vp
->v_type
!= VDIR
&&
360 (uio
->uio_offset
+ uio
->uio_resid
) > nmp
->nm_maxfilesize
)
362 biosize
= vp
->v_mount
->mnt_stat
.f_iosize
;
363 seqcount
= (int)((off_t
)(ioflag
>> IO_SEQSHIFT
) * biosize
/ BKVASIZE
);
366 * For nfs, cache consistency can only be maintained approximately.
367 * Although RFC1094 does not specify the criteria, the following is
368 * believed to be compatible with the reference port.
370 * NQNFS: Full cache coherency is maintained within the loop.
372 * NFS: If local changes have been made and this is a
373 * directory, the directory must be invalidated and
374 * the attribute cache must be cleared.
376 * GETATTR is called to synchronize the file size.
378 * If remote changes are detected local data is flushed
379 * and the cache is invalidated.
382 * NOTE: In the normal case the attribute cache is not
383 * cleared which means GETATTR may use cached data and
384 * not immediately detect changes made on the server.
386 if ((nmp
->nm_flag
& NFSMNT_NQNFS
) == 0) {
387 if ((np
->n_flag
& NLMODIFIED
) && vp
->v_type
== VDIR
) {
389 error
= nfs_vinvalbuf(vp
, V_SAVE
, td
, 1);
394 error
= VOP_GETATTR(vp
, &vattr
, td
);
397 if (np
->n_flag
& NRMODIFIED
) {
398 if (vp
->v_type
== VDIR
)
400 error
= nfs_vinvalbuf(vp
, V_SAVE
, td
, 1);
403 np
->n_flag
&= ~NRMODIFIED
;
409 * Get a valid lease. If cached data is stale, flush it.
411 if (nmp
->nm_flag
& NFSMNT_NQNFS
) {
412 if (NQNFS_CKINVALID(vp
, np
, ND_READ
)) {
414 error
= nqnfs_getlease(vp
, ND_READ
, td
);
415 } while (error
== NQNFS_EXPIRED
);
418 if (np
->n_lrev
!= np
->n_brev
||
419 (np
->n_flag
& NQNFSNONCACHE
) ||
420 ((np
->n_flag
& NLMODIFIED
) && vp
->v_type
== VDIR
)) {
421 if (vp
->v_type
== VDIR
)
423 error
= nfs_vinvalbuf(vp
, V_SAVE
, td
, 1);
426 np
->n_brev
= np
->n_lrev
;
428 } else if (vp
->v_type
== VDIR
&& (np
->n_flag
& NLMODIFIED
)) {
430 error
= nfs_vinvalbuf(vp
, V_SAVE
, td
, 1);
435 if (np
->n_flag
& NQNFSNONCACHE
) {
436 switch (vp
->v_type
) {
438 return (nfs_readrpc(vp
, uio
));
440 return (nfs_readlinkrpc(vp
, uio
));
444 printf(" NQNFSNONCACHE: type %x unexpected\n",
448 switch (vp
->v_type
) {
450 nfsstats
.biocache_reads
++;
451 lbn
= uio
->uio_offset
/ biosize
;
452 on
= uio
->uio_offset
& (biosize
- 1);
455 * Start the read ahead(s), as required.
457 if (nfs_numasync
> 0 && nmp
->nm_readahead
> 0) {
458 for (nra
= 0; nra
< nmp
->nm_readahead
&& nra
< seqcount
&&
459 (off_t
)(lbn
+ 1 + nra
) * biosize
< np
->n_size
; nra
++) {
460 rabn
= lbn
+ 1 + nra
;
461 if (!findblk(vp
, rabn
)) {
462 rabp
= nfs_getcacheblk(vp
, rabn
, biosize
, td
);
465 if ((rabp
->b_flags
& (B_CACHE
|B_DELWRI
)) == 0) {
466 rabp
->b_flags
|= (B_READ
| B_ASYNC
);
467 vfs_busy_pages(rabp
, 0);
468 if (nfs_asyncio(vp
, &rabp
->b_bio2
, td
)) {
469 rabp
->b_flags
|= B_INVAL
|B_ERROR
;
470 vfs_unbusy_pages(rabp
);
482 * Obtain the buffer cache block. Figure out the buffer size
483 * when we are at EOF. If we are modifying the size of the
484 * buffer based on an EOF condition we need to hold
485 * nfs_rslock() through obtaining the buffer to prevent
486 * a potential writer-appender from messing with n_size.
487 * Otherwise we may accidently truncate the buffer and
490 * Note that bcount is *not* DEV_BSIZE aligned.
495 if ((off_t
)lbn
* biosize
>= np
->n_size
) {
497 } else if ((off_t
)(lbn
+ 1) * biosize
> np
->n_size
) {
498 bcount
= np
->n_size
- (off_t
)lbn
* biosize
;
500 if (bcount
!= biosize
) {
501 switch(nfs_rslock(np
, td
)) {
514 bp
= nfs_getcacheblk(vp
, lbn
, bcount
, td
);
516 if (bcount
!= biosize
)
517 nfs_rsunlock(np
, td
);
522 * If B_CACHE is not set, we must issue the read. If this
523 * fails, we return an error.
526 if ((bp
->b_flags
& B_CACHE
) == 0) {
527 bp
->b_flags
|= B_READ
;
528 vfs_busy_pages(bp
, 0);
529 error
= nfs_doio(vp
, &bp
->b_bio2
, td
);
537 * on is the offset into the current bp. Figure out how many
538 * bytes we can copy out of the bp. Note that bcount is
539 * NOT DEV_BSIZE aligned.
541 * Then figure out how many bytes we can copy into the uio.
546 n
= min((unsigned)(bcount
- on
), uio
->uio_resid
);
549 nfsstats
.biocache_readlinks
++;
550 bp
= nfs_getcacheblk(vp
, (daddr_t
)0, NFS_MAXPATHLEN
, td
);
553 if ((bp
->b_flags
& B_CACHE
) == 0) {
554 bp
->b_flags
|= B_READ
;
555 vfs_busy_pages(bp
, 0);
556 error
= nfs_doio(vp
, &bp
->b_bio2
, td
);
558 bp
->b_flags
|= B_ERROR
;
563 n
= min(uio
->uio_resid
, NFS_MAXPATHLEN
- bp
->b_resid
);
567 nfsstats
.biocache_readdirs
++;
568 if (np
->n_direofoffset
569 && uio
->uio_offset
>= np
->n_direofoffset
) {
572 lbn
= (uoff_t
)uio
->uio_offset
/ NFS_DIRBLKSIZ
;
573 on
= uio
->uio_offset
& (NFS_DIRBLKSIZ
- 1);
574 bp
= nfs_getcacheblk(vp
, lbn
, NFS_DIRBLKSIZ
, td
);
577 if ((bp
->b_flags
& B_CACHE
) == 0) {
578 bp
->b_flags
|= B_READ
;
579 vfs_busy_pages(bp
, 0);
580 error
= nfs_doio(vp
, &bp
->b_bio2
, td
);
584 while (error
== NFSERR_BAD_COOKIE
) {
585 printf("got bad cookie vp %p bp %p\n", vp
, bp
);
587 error
= nfs_vinvalbuf(vp
, 0, td
, 1);
589 * Yuck! The directory has been modified on the
590 * server. The only way to get the block is by
591 * reading from the beginning to get all the
594 * Leave the last bp intact unless there is an error.
595 * Loop back up to the while if the error is another
596 * NFSERR_BAD_COOKIE (double yuch!).
598 for (i
= 0; i
<= lbn
&& !error
; i
++) {
599 if (np
->n_direofoffset
600 && (i
* NFS_DIRBLKSIZ
) >= np
->n_direofoffset
)
602 bp
= nfs_getcacheblk(vp
, i
, NFS_DIRBLKSIZ
, td
);
605 if ((bp
->b_flags
& B_CACHE
) == 0) {
606 bp
->b_flags
|= B_READ
;
607 vfs_busy_pages(bp
, 0);
608 error
= nfs_doio(vp
, &bp
->b_bio2
, td
);
610 * no error + B_INVAL == directory EOF,
613 if (error
== 0 && (bp
->b_flags
& B_INVAL
))
617 * An error will throw away the block and the
618 * for loop will break out. If no error and this
619 * is not the block we want, we throw away the
620 * block and go for the next one via the for loop.
622 if (error
|| i
< lbn
)
627 * The above while is repeated if we hit another cookie
628 * error. If we hit an error and it wasn't a cookie error,
636 * If not eof and read aheads are enabled, start one.
637 * (You need the current block first, so that you have the
638 * directory offset cookie of the next block.)
640 if (nfs_numasync
> 0 && nmp
->nm_readahead
> 0 &&
641 (bp
->b_flags
& B_INVAL
) == 0 &&
642 (np
->n_direofoffset
== 0 ||
643 (lbn
+ 1) * NFS_DIRBLKSIZ
< np
->n_direofoffset
) &&
644 !(np
->n_flag
& NQNFSNONCACHE
) &&
645 !findblk(vp
, lbn
+ 1)) {
646 rabp
= nfs_getcacheblk(vp
, lbn
+ 1, NFS_DIRBLKSIZ
, td
);
648 if ((rabp
->b_flags
& (B_CACHE
|B_DELWRI
)) == 0) {
649 rabp
->b_flags
|= (B_READ
| B_ASYNC
);
650 vfs_busy_pages(rabp
, 0);
651 if (nfs_asyncio(vp
, &rabp
->b_bio2
, td
)) {
652 rabp
->b_flags
|= B_INVAL
|B_ERROR
;
653 vfs_unbusy_pages(rabp
);
662 * Unlike VREG files, whos buffer size ( bp->b_bcount ) is
663 * chopped for the EOF condition, we cannot tell how large
664 * NFS directories are going to be until we hit EOF. So
665 * an NFS directory buffer is *not* chopped to its EOF. Now,
666 * it just so happens that b_resid will effectively chop it
667 * to EOF. *BUT* this information is lost if the buffer goes
668 * away and is reconstituted into a B_CACHE state ( due to
669 * being VMIO ) later. So we keep track of the directory eof
670 * in np->n_direofoffset and chop it off as an extra step
673 n
= lmin(uio
->uio_resid
, NFS_DIRBLKSIZ
- bp
->b_resid
- on
);
674 if (np
->n_direofoffset
&& n
> np
->n_direofoffset
- uio
->uio_offset
)
675 n
= np
->n_direofoffset
- uio
->uio_offset
;
678 printf(" nfs_bioread: type %x unexpected\n",vp
->v_type
);
682 switch (vp
->v_type
) {
685 error
= uiomove(bp
->b_data
+ on
, (int)n
, uio
);
689 error
= uiomove(bp
->b_data
+ on
, (int)n
, uio
);
694 off_t old_off
= uio
->uio_offset
;
696 struct nfs_dirent
*dp
;
698 cpos
= bp
->b_data
+ on
;
699 epos
= bp
->b_data
+ on
+ n
;
700 while (cpos
< epos
&& error
== 0 && uio
->uio_resid
> 0) {
701 dp
= (struct nfs_dirent
*)cpos
;
702 if (vop_write_dirent(&error
, uio
, dp
->nfs_ino
,
703 dp
->nfs_type
, dp
->nfs_namlen
, dp
->nfs_name
))
705 cpos
+= dp
->nfs_reclen
;
709 uio
->uio_offset
= old_off
+ cpos
- bp
->b_data
- on
;
712 * Invalidate buffer if caching is disabled, forcing a
713 * re-read from the remote later.
715 if (np
->n_flag
& NQNFSNONCACHE
)
716 bp
->b_flags
|= B_INVAL
;
719 printf(" nfs_bioread: type %x unexpected\n",vp
->v_type
);
722 } while (error
== 0 && uio
->uio_resid
> 0 && n
> 0);
727 * Vnode op for write using bio
729 * nfs_write(struct vnode *a_vp, struct uio *a_uio, int a_ioflag,
730 * struct ucred *a_cred)
733 nfs_write(struct vop_write_args
*ap
)
735 struct uio
*uio
= ap
->a_uio
;
736 struct thread
*td
= uio
->uio_td
;
737 struct vnode
*vp
= ap
->a_vp
;
738 struct nfsnode
*np
= VTONFS(vp
);
739 int ioflag
= ap
->a_ioflag
;
742 struct nfsmount
*nmp
= VFSTONFS(vp
->v_mount
);
744 int n
, on
, error
= 0, iomode
, must_commit
;
750 if (uio
->uio_rw
!= UIO_WRITE
)
751 panic("nfs_write mode");
752 if (uio
->uio_segflg
== UIO_USERSPACE
&& uio
->uio_td
!= curthread
)
753 panic("nfs_write proc");
755 if (vp
->v_type
!= VREG
)
757 if (np
->n_flag
& NWRITEERR
) {
758 np
->n_flag
&= ~NWRITEERR
;
759 return (np
->n_error
);
761 if ((nmp
->nm_flag
& NFSMNT_NFSV3
) != 0 &&
762 (nmp
->nm_state
& NFSSTA_GOTFSINFO
) == 0)
763 (void)nfs_fsinfo(nmp
, vp
, td
);
766 * Synchronously flush pending buffers if we are in synchronous
767 * mode or if we are appending.
769 if (ioflag
& (IO_APPEND
| IO_SYNC
)) {
770 if (np
->n_flag
& NLMODIFIED
) {
772 error
= nfs_flush(vp
, MNT_WAIT
, td
, 0);
773 /* error = nfs_vinvalbuf(vp, V_SAVE, td, 1); */
780 * If IO_APPEND then load uio_offset. We restart here if we cannot
781 * get the append lock.
784 if (ioflag
& IO_APPEND
) {
786 error
= VOP_GETATTR(vp
, &vattr
, td
);
789 uio
->uio_offset
= np
->n_size
;
792 if (uio
->uio_offset
< 0)
794 if ((uio
->uio_offset
+ uio
->uio_resid
) > nmp
->nm_maxfilesize
)
796 if (uio
->uio_resid
== 0)
800 * We need to obtain the rslock if we intend to modify np->n_size
801 * in order to guarentee the append point with multiple contending
802 * writers, to guarentee that no other appenders modify n_size
803 * while we are trying to obtain a truncated buffer (i.e. to avoid
804 * accidently truncating data written by another appender due to
805 * the race), and to ensure that the buffer is populated prior to
806 * our extending of the file. We hold rslock through the entire
809 * Note that we do not synchronize the case where someone truncates
810 * the file while we are appending to it because attempting to lock
811 * this case may deadlock other parts of the system unexpectedly.
813 if ((ioflag
& IO_APPEND
) ||
814 uio
->uio_offset
+ uio
->uio_resid
> np
->n_size
) {
815 switch(nfs_rslock(np
, td
)) {
830 * Maybe this should be above the vnode op call, but so long as
831 * file servers have no limits, i don't think it matters
833 if (td
->td_proc
&& uio
->uio_offset
+ uio
->uio_resid
>
834 td
->td_proc
->p_rlimit
[RLIMIT_FSIZE
].rlim_cur
) {
835 psignal(td
->td_proc
, SIGXFSZ
);
837 nfs_rsunlock(np
, td
);
841 biosize
= vp
->v_mount
->mnt_stat
.f_iosize
;
845 * Check for a valid write lease.
847 if ((nmp
->nm_flag
& NFSMNT_NQNFS
) &&
848 NQNFS_CKINVALID(vp
, np
, ND_WRITE
)) {
850 error
= nqnfs_getlease(vp
, ND_WRITE
, td
);
851 } while (error
== NQNFS_EXPIRED
);
854 if (np
->n_lrev
!= np
->n_brev
||
855 (np
->n_flag
& NQNFSNONCACHE
)) {
856 error
= nfs_vinvalbuf(vp
, V_SAVE
, td
, 1);
859 np
->n_brev
= np
->n_lrev
;
862 if ((np
->n_flag
& NQNFSNONCACHE
) && uio
->uio_iovcnt
== 1) {
863 iomode
= NFSV3WRITE_FILESYNC
;
864 error
= nfs_writerpc(vp
, uio
, &iomode
, &must_commit
);
866 nfs_clearcommit(vp
->v_mount
);
869 nfsstats
.biocache_writes
++;
870 lbn
= uio
->uio_offset
/ biosize
;
871 on
= uio
->uio_offset
& (biosize
-1);
872 n
= min((unsigned)(biosize
- on
), uio
->uio_resid
);
875 * Handle direct append and file extension cases, calculate
876 * unaligned buffer size.
879 if (uio
->uio_offset
== np
->n_size
&& n
) {
881 * Get the buffer (in its pre-append state to maintain
882 * B_CACHE if it was previously set). Resize the
883 * nfsnode after we have locked the buffer to prevent
884 * readers from reading garbage.
887 bp
= nfs_getcacheblk(vp
, lbn
, bcount
, td
);
892 np
->n_size
= uio
->uio_offset
+ n
;
893 np
->n_flag
|= NLMODIFIED
;
894 vnode_pager_setsize(vp
, np
->n_size
);
896 save
= bp
->b_flags
& B_CACHE
;
898 allocbuf(bp
, bcount
);
903 * Obtain the locked cache block first, and then
904 * adjust the file's size as appropriate.
907 if ((off_t
)lbn
* biosize
+ bcount
< np
->n_size
) {
908 if ((off_t
)(lbn
+ 1) * biosize
< np
->n_size
)
911 bcount
= np
->n_size
- (off_t
)lbn
* biosize
;
913 bp
= nfs_getcacheblk(vp
, lbn
, bcount
, td
);
914 if (uio
->uio_offset
+ n
> np
->n_size
) {
915 np
->n_size
= uio
->uio_offset
+ n
;
916 np
->n_flag
|= NLMODIFIED
;
917 vnode_pager_setsize(vp
, np
->n_size
);
927 * Issue a READ if B_CACHE is not set. In special-append
928 * mode, B_CACHE is based on the buffer prior to the write
929 * op and is typically set, avoiding the read. If a read
930 * is required in special append mode, the server will
931 * probably send us a short-read since we extended the file
932 * on our end, resulting in b_resid == 0 and, thusly,
933 * B_CACHE getting set.
935 * We can also avoid issuing the read if the write covers
936 * the entire buffer. We have to make sure the buffer state
937 * is reasonable in this case since we will not be initiating
938 * I/O. See the comments in kern/vfs_bio.c's getblk() for
941 * B_CACHE may also be set due to the buffer being cached
945 if (on
== 0 && n
== bcount
) {
946 bp
->b_flags
|= B_CACHE
;
947 bp
->b_flags
&= ~(B_ERROR
| B_INVAL
);
950 if ((bp
->b_flags
& B_CACHE
) == 0) {
951 bp
->b_flags
|= B_READ
;
952 vfs_busy_pages(bp
, 0);
953 error
= nfs_doio(vp
, &bp
->b_bio2
, td
);
963 np
->n_flag
|= NLMODIFIED
;
966 * If dirtyend exceeds file size, chop it down. This should
967 * not normally occur but there is an append race where it
968 * might occur XXX, so we log it.
970 * If the chopping creates a reverse-indexed or degenerate
971 * situation with dirtyoff/end, we 0 both of them.
974 if (bp
->b_dirtyend
> bcount
) {
975 printf("NFS append race @%llx:%d\n",
976 (off_t
)bp
->b_bio2
.bio_blkno
<< DEV_BSHIFT
,
977 bp
->b_dirtyend
- bcount
);
978 bp
->b_dirtyend
= bcount
;
981 if (bp
->b_dirtyoff
>= bp
->b_dirtyend
)
982 bp
->b_dirtyoff
= bp
->b_dirtyend
= 0;
985 * If the new write will leave a contiguous dirty
986 * area, just update the b_dirtyoff and b_dirtyend,
987 * otherwise force a write rpc of the old dirty area.
989 * While it is possible to merge discontiguous writes due to
990 * our having a B_CACHE buffer ( and thus valid read data
991 * for the hole), we don't because it could lead to
992 * significant cache coherency problems with multiple clients,
993 * especially if locking is implemented later on.
995 * as an optimization we could theoretically maintain
996 * a linked list of discontinuous areas, but we would still
997 * have to commit them separately so there isn't much
998 * advantage to it except perhaps a bit of asynchronization.
1001 if (bp
->b_dirtyend
> 0 &&
1002 (on
> bp
->b_dirtyend
|| (on
+ n
) < bp
->b_dirtyoff
)) {
1003 if (VOP_BWRITE(vp
, bp
) == EINTR
) {
1011 * Check for valid write lease and get one as required.
1012 * In case getblk() and/or bwrite() delayed us.
1014 if ((nmp
->nm_flag
& NFSMNT_NQNFS
) &&
1015 NQNFS_CKINVALID(vp
, np
, ND_WRITE
)) {
1017 error
= nqnfs_getlease(vp
, ND_WRITE
, td
);
1018 } while (error
== NQNFS_EXPIRED
);
1023 if (np
->n_lrev
!= np
->n_brev
||
1024 (np
->n_flag
& NQNFSNONCACHE
)) {
1026 error
= nfs_vinvalbuf(vp
, V_SAVE
, td
, 1);
1029 np
->n_brev
= np
->n_lrev
;
1034 error
= uiomove((char *)bp
->b_data
+ on
, n
, uio
);
1037 * Since this block is being modified, it must be written
1038 * again and not just committed. Since write clustering does
1039 * not work for the stage 1 data write, only the stage 2
1040 * commit rpc, we have to clear B_CLUSTEROK as well.
1042 bp
->b_flags
&= ~(B_NEEDCOMMIT
| B_CLUSTEROK
);
1045 bp
->b_flags
|= B_ERROR
;
1051 * Only update dirtyoff/dirtyend if not a degenerate
1055 if (bp
->b_dirtyend
> 0) {
1056 bp
->b_dirtyoff
= min(on
, bp
->b_dirtyoff
);
1057 bp
->b_dirtyend
= max((on
+ n
), bp
->b_dirtyend
);
1059 bp
->b_dirtyoff
= on
;
1060 bp
->b_dirtyend
= on
+ n
;
1062 vfs_bio_set_validclean(bp
, on
, n
);
1065 * If IO_NOWDRAIN then set B_NOWDRAIN (e.g. nfs-backed VN
1066 * filesystem). XXX also use for loopback NFS mounts.
1068 if (ioflag
& IO_NOWDRAIN
)
1069 bp
->b_flags
|= B_NOWDRAIN
;
1072 * If the lease is non-cachable or IO_SYNC do bwrite().
1074 * IO_INVAL appears to be unused. The idea appears to be
1075 * to turn off caching in this case. Very odd. XXX
1077 if ((np
->n_flag
& NQNFSNONCACHE
) || (ioflag
& IO_SYNC
)) {
1078 if (ioflag
& IO_INVAL
)
1079 bp
->b_flags
|= B_NOCACHE
;
1080 error
= VOP_BWRITE(vp
, bp
);
1083 if (np
->n_flag
& NQNFSNONCACHE
) {
1084 error
= nfs_vinvalbuf(vp
, V_SAVE
, td
, 1);
1088 } else if ((n
+ on
) == biosize
&&
1089 (nmp
->nm_flag
& NFSMNT_NQNFS
) == 0) {
1090 bp
->b_flags
|= B_ASYNC
;
1091 nfs_writebp(bp
, 0, 0);
1095 } while (uio
->uio_resid
> 0 && n
> 0);
1098 nfs_rsunlock(np
, td
);
1104 * Get an nfs cache block.
1106 * Allocate a new one if the block isn't currently in the cache
1107 * and return the block marked busy. If the calling process is
1108 * interrupted by a signal for an interruptible mount point, return
1111 * The caller must carefully deal with the possible B_INVAL state of
1112 * the buffer. nfs_doio() clears B_INVAL (and nfs_asyncio() clears it
1113 * indirectly), so synchronous reads can be issued without worrying about
1114 * the B_INVAL state. We have to be a little more careful when dealing
1115 * with writes (see comments in nfs_write()) when extending a file past
1119 nfs_getcacheblk(struct vnode
*vp
, daddr_t bn
, int size
, struct thread
*td
)
1123 struct nfsmount
*nmp
;
1128 if (nmp
->nm_flag
& NFSMNT_INT
) {
1129 bp
= getblk(vp
, bn
, size
, PCATCH
, 0);
1130 while (bp
== NULL
) {
1131 if (nfs_sigintr(nmp
, (struct nfsreq
*)0, td
))
1133 bp
= getblk(vp
, bn
, size
, 0, 2 * hz
);
1136 bp
= getblk(vp
, bn
, size
, 0, 0);
1140 * bio2, the 'device' layer, is normalized to DEV_BSIZE'd blocks.
1142 if (vp
->v_type
== VREG
) {
1145 biosize
= mp
->mnt_stat
.f_iosize
;
1146 bp
->b_bio2
.bio_blkno
= ((off_t
)bn
* biosize
) >> DEV_BSHIFT
;
1148 bp
->b_bio2
.bio_blkno
= ((off_t
)bn
* NFS_DIRBLKSIZ
) >> DEV_BSHIFT
;
1154 * Flush and invalidate all dirty buffers. If another process is already
1155 * doing the flush, just wait for completion.
1158 nfs_vinvalbuf(struct vnode
*vp
, int flags
,
1159 struct thread
*td
, int intrflg
)
1161 struct nfsnode
*np
= VTONFS(vp
);
1162 struct nfsmount
*nmp
= VFSTONFS(vp
->v_mount
);
1163 int error
= 0, slpflag
, slptimeo
;
1165 if (vp
->v_flag
& VRECLAIMED
)
1168 if ((nmp
->nm_flag
& NFSMNT_INT
) == 0)
1178 * First wait for any other process doing a flush to complete.
1180 while (np
->n_flag
& NFLUSHINPROG
) {
1181 np
->n_flag
|= NFLUSHWANT
;
1182 error
= tsleep((caddr_t
)&np
->n_flag
, 0, "nfsvinval", slptimeo
);
1183 if (error
&& intrflg
&& nfs_sigintr(nmp
, (struct nfsreq
*)0, td
))
1188 * Now, flush as required.
1190 np
->n_flag
|= NFLUSHINPROG
;
1191 error
= vinvalbuf(vp
, flags
, td
, slpflag
, 0);
1193 if (intrflg
&& nfs_sigintr(nmp
, (struct nfsreq
*)0, td
)) {
1194 np
->n_flag
&= ~NFLUSHINPROG
;
1195 if (np
->n_flag
& NFLUSHWANT
) {
1196 np
->n_flag
&= ~NFLUSHWANT
;
1197 wakeup((caddr_t
)&np
->n_flag
);
1201 error
= vinvalbuf(vp
, flags
, td
, 0, slptimeo
);
1203 np
->n_flag
&= ~(NLMODIFIED
| NFLUSHINPROG
);
1204 if (np
->n_flag
& NFLUSHWANT
) {
1205 np
->n_flag
&= ~NFLUSHWANT
;
1206 wakeup((caddr_t
)&np
->n_flag
);
1212 * Initiate asynchronous I/O. Return an error if no nfsiods are available.
1213 * This is mainly to avoid queueing async I/O requests when the nfsiods
1214 * are all hung on a dead server.
1216 * Note: nfs_asyncio() does not clear (B_ERROR|B_INVAL) but when the bp
1217 * is eventually dequeued by the async daemon, nfs_doio() *will*.
1220 nfs_asyncio(struct vnode
*vp
, struct bio
*bio
, struct thread
*td
)
1222 struct buf
*bp
= bio
->bio_buf
;
1223 struct nfsmount
*nmp
;
1231 * If no async daemons then return EIO to force caller to run the rpc
1234 if (nfs_numasync
== 0)
1237 KKASSERT(vp
->v_tag
== VT_NFS
);
1238 nmp
= VFSTONFS(vp
->v_mount
);
1241 * Commits are usually short and sweet so lets save some cpu and
1242 * leave the async daemons for more important rpc's (such as reads
1245 if ((bp
->b_flags
& (B_READ
|B_NEEDCOMMIT
)) == B_NEEDCOMMIT
&&
1246 (nmp
->nm_bioqiods
> nfs_numasync
/ 2)) {
1251 if (nmp
->nm_flag
& NFSMNT_INT
)
1256 * Find a free iod to process this request.
1258 for (i
= 0; i
< NFS_MAXASYNCDAEMON
; i
++)
1259 if (nfs_iodwant
[i
]) {
1261 * Found one, so wake it up and tell it which
1265 ("nfs_asyncio: waking iod %d for mount %p\n",
1267 nfs_iodwant
[i
] = NULL
;
1268 nfs_iodmount
[i
] = nmp
;
1270 wakeup((caddr_t
)&nfs_iodwant
[i
]);
1276 * If none are free, we may already have an iod working on this mount
1277 * point. If so, it will process our request.
1280 if (nmp
->nm_bioqiods
> 0) {
1282 ("nfs_asyncio: %d iods are already processing mount %p\n",
1283 nmp
->nm_bioqiods
, nmp
));
1289 * If we have an iod which can process the request, then queue
1294 * Ensure that the queue never grows too large. We still want
1295 * to asynchronize so we block rather then return EIO.
1297 while (nmp
->nm_bioqlen
>= 2*nfs_numasync
) {
1299 ("nfs_asyncio: waiting for mount %p queue to drain\n", nmp
));
1300 nmp
->nm_bioqwant
= TRUE
;
1301 error
= tsleep(&nmp
->nm_bioq
, slpflag
,
1302 "nfsaio", slptimeo
);
1304 if (nfs_sigintr(nmp
, NULL
, td
))
1306 if (slpflag
== PCATCH
) {
1312 * We might have lost our iod while sleeping,
1313 * so check and loop if nescessary.
1315 if (nmp
->nm_bioqiods
== 0) {
1317 ("nfs_asyncio: no iods after mount %p queue was drained, looping\n", nmp
));
1324 * The passed bio's buffer is not necessary associated with
1325 * the NFS vnode it is being written to. Store the NFS vnode
1326 * in the BIO driver info.
1328 bio
->bio_driver_info
= vp
;
1329 TAILQ_INSERT_TAIL(&nmp
->nm_bioq
, bio
, bio_act
);
1335 * All the iods are busy on other mounts, so return EIO to
1336 * force the caller to process the i/o synchronously.
1338 NFS_DPF(ASYNCIO
, ("nfs_asyncio: no iods available, i/o is synchronous\n"));
1343 * Do an I/O operation to/from a cache block. This may be called
1344 * synchronously or from an nfsiod. The BIO is normalized for DEV_BSIZE.
1346 * NOTE! TD MIGHT BE NULL
1349 nfs_doio(struct vnode
*vp
, struct bio
*bio
, struct thread
*td
)
1351 struct buf
*bp
= bio
->bio_buf
;
1354 struct nfsmount
*nmp
;
1355 int error
= 0, iomode
, must_commit
= 0;
1359 KKASSERT(vp
->v_tag
== VT_NFS
);
1361 nmp
= VFSTONFS(vp
->v_mount
);
1363 uiop
->uio_iov
= &io
;
1364 uiop
->uio_iovcnt
= 1;
1365 uiop
->uio_segflg
= UIO_SYSSPACE
;
1369 * clear B_ERROR and B_INVAL state prior to initiating the I/O. We
1370 * do this here so we do not have to do it in all the code that
1373 bp
->b_flags
&= ~(B_ERROR
| B_INVAL
);
1375 KASSERT(!(bp
->b_flags
& B_DONE
), ("nfs_doio: bp %p already marked done", bp
));
1378 * Historically, paging was done with physio, but no more.
1380 if (bp
->b_flags
& B_PHYS
) {
1382 * ...though reading /dev/drum still gets us here.
1384 io
.iov_len
= uiop
->uio_resid
= bp
->b_bcount
;
1385 /* mapping was done by vmapbuf() */
1386 io
.iov_base
= bp
->b_data
;
1387 uiop
->uio_offset
= (off_t
)bio
->bio_blkno
<< DEV_BSHIFT
;
1388 if (bp
->b_flags
& B_READ
) {
1389 uiop
->uio_rw
= UIO_READ
;
1390 nfsstats
.read_physios
++;
1391 error
= nfs_readrpc(vp
, uiop
);
1395 iomode
= NFSV3WRITE_DATASYNC
;
1396 uiop
->uio_rw
= UIO_WRITE
;
1397 nfsstats
.write_physios
++;
1398 error
= nfs_writerpc(vp
, uiop
, &iomode
, &com
);
1401 bp
->b_flags
|= B_ERROR
;
1402 bp
->b_error
= error
;
1404 } else if (bp
->b_flags
& B_READ
) {
1405 io
.iov_len
= uiop
->uio_resid
= bp
->b_bcount
;
1406 io
.iov_base
= bp
->b_data
;
1407 uiop
->uio_rw
= UIO_READ
;
1409 switch (vp
->v_type
) {
1411 uiop
->uio_offset
= (off_t
)bio
->bio_blkno
<< DEV_BSHIFT
;
1412 nfsstats
.read_bios
++;
1413 error
= nfs_readrpc(vp
, uiop
);
1416 if (uiop
->uio_resid
) {
1418 * If we had a short read with no error, we must have
1419 * hit a file hole. We should zero-fill the remainder.
1420 * This can also occur if the server hits the file EOF.
1422 * Holes used to be able to occur due to pending
1423 * writes, but that is not possible any longer.
1425 int nread
= bp
->b_bcount
- uiop
->uio_resid
;
1426 int left
= uiop
->uio_resid
;
1429 bzero((char *)bp
->b_data
+ nread
, left
);
1430 uiop
->uio_resid
= 0;
1433 if (td
&& td
->td_proc
&& (vp
->v_flag
& VTEXT
) &&
1434 (((nmp
->nm_flag
& NFSMNT_NQNFS
) &&
1435 NQNFS_CKINVALID(vp
, np
, ND_READ
) &&
1436 np
->n_lrev
!= np
->n_brev
) ||
1437 (!(nmp
->nm_flag
& NFSMNT_NQNFS
) &&
1438 np
->n_mtime
!= np
->n_vattr
.va_mtime
.tv_sec
))) {
1439 uprintf("Process killed due to text file modification\n");
1440 psignal(td
->td_proc
, SIGKILL
);
1444 uiop
->uio_offset
= 0;
1445 nfsstats
.readlink_bios
++;
1446 error
= nfs_readlinkrpc(vp
, uiop
);
1449 nfsstats
.readdir_bios
++;
1450 uiop
->uio_offset
= (off_t
)bio
->bio_blkno
<< DEV_BSHIFT
;
1451 if (nmp
->nm_flag
& NFSMNT_RDIRPLUS
) {
1452 error
= nfs_readdirplusrpc(vp
, uiop
);
1453 if (error
== NFSERR_NOTSUPP
)
1454 nmp
->nm_flag
&= ~NFSMNT_RDIRPLUS
;
1456 if ((nmp
->nm_flag
& NFSMNT_RDIRPLUS
) == 0)
1457 error
= nfs_readdirrpc(vp
, uiop
);
1459 * end-of-directory sets B_INVAL but does not generate an
1462 if (error
== 0 && uiop
->uio_resid
== bp
->b_bcount
)
1463 bp
->b_flags
|= B_INVAL
;
1466 printf("nfs_doio: type %x unexpected\n",vp
->v_type
);
1470 bp
->b_flags
|= B_ERROR
;
1471 bp
->b_error
= error
;
1475 * If we only need to commit, try to commit
1477 if (bp
->b_flags
& B_NEEDCOMMIT
) {
1481 off
= ((off_t
)bio
->bio_blkno
<< DEV_BSHIFT
) +
1483 retv
= nfs_commit(vp
, off
,
1484 bp
->b_dirtyend
- bp
->b_dirtyoff
, td
);
1486 bp
->b_dirtyoff
= bp
->b_dirtyend
= 0;
1487 bp
->b_flags
&= ~(B_NEEDCOMMIT
| B_CLUSTEROK
);
1492 if (retv
== NFSERR_STALEWRITEVERF
) {
1493 nfs_clearcommit(vp
->v_mount
);
1498 * Setup for actual write
1501 if (((off_t
)bio
->bio_blkno
<< DEV_BSHIFT
) + bp
->b_dirtyend
> np
->n_size
)
1502 bp
->b_dirtyend
= np
->n_size
- ((off_t
)bio
->bio_blkno
<< DEV_BSHIFT
);
1504 if (bp
->b_dirtyend
> bp
->b_dirtyoff
) {
1505 io
.iov_len
= uiop
->uio_resid
= bp
->b_dirtyend
1507 uiop
->uio_offset
= ((off_t
)bio
->bio_blkno
<< DEV_BSHIFT
)
1509 io
.iov_base
= (char *)bp
->b_data
+ bp
->b_dirtyoff
;
1510 uiop
->uio_rw
= UIO_WRITE
;
1511 nfsstats
.write_bios
++;
1513 if ((bp
->b_flags
& (B_ASYNC
| B_NEEDCOMMIT
| B_NOCACHE
| B_CLUSTER
)) == B_ASYNC
)
1514 iomode
= NFSV3WRITE_UNSTABLE
;
1516 iomode
= NFSV3WRITE_FILESYNC
;
1518 error
= nfs_writerpc(vp
, uiop
, &iomode
, &must_commit
);
1521 * When setting B_NEEDCOMMIT also set B_CLUSTEROK to try
1522 * to cluster the buffers needing commit. This will allow
1523 * the system to submit a single commit rpc for the whole
1524 * cluster. We can do this even if the buffer is not 100%
1525 * dirty (relative to the NFS blocksize), so we optimize the
1526 * append-to-file-case.
1528 * (when clearing B_NEEDCOMMIT, B_CLUSTEROK must also be
1529 * cleared because write clustering only works for commit
1530 * rpc's, not for the data portion of the write).
1533 if (!error
&& iomode
== NFSV3WRITE_UNSTABLE
) {
1534 bp
->b_flags
|= B_NEEDCOMMIT
;
1535 if (bp
->b_dirtyoff
== 0
1536 && bp
->b_dirtyend
== bp
->b_bcount
)
1537 bp
->b_flags
|= B_CLUSTEROK
;
1539 bp
->b_flags
&= ~(B_NEEDCOMMIT
| B_CLUSTEROK
);
1543 * For an interrupted write, the buffer is still valid
1544 * and the write hasn't been pushed to the server yet,
1545 * so we can't set B_ERROR and report the interruption
1546 * by setting B_EINTR. For the B_ASYNC case, B_EINTR
1547 * is not relevant, so the rpc attempt is essentially
1548 * a noop. For the case of a V3 write rpc not being
1549 * committed to stable storage, the block is still
1550 * dirty and requires either a commit rpc or another
1551 * write rpc with iomode == NFSV3WRITE_FILESYNC before
1552 * the block is reused. This is indicated by setting
1553 * the B_DELWRI and B_NEEDCOMMIT flags.
1555 * If the buffer is marked B_PAGING, it does not reside on
1556 * the vp's paging queues so we cannot call bdirty(). The
1557 * bp in this case is not an NFS cache block so we should
1561 || (!error
&& (bp
->b_flags
& B_NEEDCOMMIT
))) {
1563 bp
->b_flags
&= ~(B_INVAL
|B_NOCACHE
);
1564 if ((bp
->b_flags
& B_PAGING
) == 0) {
1566 bp
->b_flags
&= ~B_DONE
;
1568 if (error
&& (bp
->b_flags
& B_ASYNC
) == 0)
1569 bp
->b_flags
|= B_EINTR
;
1573 bp
->b_flags
|= B_ERROR
;
1574 bp
->b_error
= np
->n_error
= error
;
1575 np
->n_flag
|= NWRITEERR
;
1577 bp
->b_dirtyoff
= bp
->b_dirtyend
= 0;
1585 bp
->b_resid
= uiop
->uio_resid
;
1587 nfs_clearcommit(vp
->v_mount
);
1593 * Used to aid in handling ftruncate() operations on the NFS client side.
1594 * Truncation creates a number of special problems for NFS. We have to
1595 * throw away VM pages and buffer cache buffers that are beyond EOF, and
1596 * we have to properly handle VM pages or (potentially dirty) buffers
1597 * that straddle the truncation point.
1601 nfs_meta_setsize(struct vnode
*vp
, struct thread
*td
, u_quad_t nsize
)
1603 struct nfsnode
*np
= VTONFS(vp
);
1604 u_quad_t tsize
= np
->n_size
;
1605 int biosize
= vp
->v_mount
->mnt_stat
.f_iosize
;
1610 if (np
->n_size
< tsize
) {
1616 * vtruncbuf() doesn't get the buffer overlapping the
1617 * truncation point. We may have a B_DELWRI and/or B_CACHE
1618 * buffer that now needs to be truncated.
1620 error
= vtruncbuf(vp
, td
, nsize
, biosize
);
1621 lbn
= nsize
/ biosize
;
1622 bufsize
= nsize
& (biosize
- 1);
1623 bp
= nfs_getcacheblk(vp
, lbn
, bufsize
, td
);
1624 if (bp
->b_dirtyoff
> bp
->b_bcount
)
1625 bp
->b_dirtyoff
= bp
->b_bcount
;
1626 if (bp
->b_dirtyend
> bp
->b_bcount
)
1627 bp
->b_dirtyend
= bp
->b_bcount
;
1628 bp
->b_flags
|= B_RELBUF
; /* don't leave garbage around */
1631 vnode_pager_setsize(vp
, nsize
);