FreeBSD/Linux Kernel Cross Reference
sys/nfs/nfs_bio.c
1 /* $NetBSD: nfs_bio.c,v 1.128.2.2 2005/11/21 20:51:21 tron Exp $ */
2
3 /*
4 * Copyright (c) 1989, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * This code is derived from software contributed to Berkeley by
8 * Rick Macklem at The University of Guelph.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. Neither the name of the University nor the names of its contributors
19 * may be used to endorse or promote products derived from this software
20 * without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 *
34 * @(#)nfs_bio.c 8.9 (Berkeley) 3/30/95
35 */
36
37 #include <sys/cdefs.h>
38 __KERNEL_RCSID(0, "$NetBSD: nfs_bio.c,v 1.128.2.2 2005/11/21 20:51:21 tron Exp $");
39
40 #include "opt_nfs.h"
41 #include "opt_ddb.h"
42
43 #include <sys/param.h>
44 #include <sys/systm.h>
45 #include <sys/resourcevar.h>
46 #include <sys/signalvar.h>
47 #include <sys/proc.h>
48 #include <sys/buf.h>
49 #include <sys/vnode.h>
50 #include <sys/mount.h>
51 #include <sys/kernel.h>
52 #include <sys/namei.h>
53 #include <sys/dirent.h>
54 #include <sys/malloc.h>
55
56 #include <uvm/uvm_extern.h>
57 #include <uvm/uvm.h>
58
59 #include <nfs/rpcv2.h>
60 #include <nfs/nfsproto.h>
61 #include <nfs/nfs.h>
62 #include <nfs/nfsmount.h>
63 #include <nfs/nqnfs.h>
64 #include <nfs/nfsnode.h>
65 #include <nfs/nfs_var.h>
66
67 extern int nfs_numasync;
68 extern int nfs_commitsize;
69 extern struct nfsstats nfsstats;
70
71 static int nfs_doio_read __P((struct buf *, struct uio *));
72 static int nfs_doio_write __P((struct buf *, struct uio *));
73 static int nfs_doio_phys __P((struct buf *, struct uio *));
74
75 /*
76 * Vnode op for read using bio
77 * Any similarity to readip() is purely coincidental
78 */
79 int
80 nfs_bioread(vp, uio, ioflag, cred, cflag)
81 struct vnode *vp;
82 struct uio *uio;
83 int ioflag, cflag;
84 struct ucred *cred;
85 {
86 struct nfsnode *np = VTONFS(vp);
87 struct buf *bp = NULL, *rabp;
88 struct proc *p;
89 struct nfsmount *nmp = VFSTONFS(vp->v_mount);
90 struct nfsdircache *ndp = NULL, *nndp = NULL;
91 caddr_t baddr, ep, edp;
92 int got_buf = 0, error = 0, n = 0, on = 0, en, enn;
93 int enough = 0;
94 struct dirent *dp, *pdp;
95 off_t curoff = 0;
96
97 #ifdef DIAGNOSTIC
98 if (uio->uio_rw != UIO_READ)
99 panic("nfs_read mode");
100 #endif
101 if (uio->uio_resid == 0)
102 return (0);
103 if (vp->v_type != VDIR && uio->uio_offset < 0)
104 return (EINVAL);
105 p = uio->uio_procp;
106 #ifndef NFS_V2_ONLY
107 if ((nmp->nm_flag & NFSMNT_NFSV3) &&
108 !(nmp->nm_iflag & NFSMNT_GOTFSINFO))
109 (void)nfs_fsinfo(nmp, vp, cred, p);
110 #endif
111 if (vp->v_type != VDIR &&
112 (uio->uio_offset + uio->uio_resid) > nmp->nm_maxfilesize)
113 return (EFBIG);
114
115 /*
116 * For nfs, cache consistency can only be maintained approximately.
117 * Although RFC1094 does not specify the criteria, the following is
118 * believed to be compatible with the reference port.
119 * For nqnfs, full cache consistency is maintained within the loop.
120 * For nfs:
121 * If the file's modify time on the server has changed since the
122 * last read rpc or you have written to the file,
123 * you may have lost data cache consistency with the
124 * server, so flush all of the file's data out of the cache.
125 * Then force a getattr rpc to ensure that you have up to date
126 * attributes.
127 * NB: This implies that cache data can be read when up to
128 * NFS_ATTRTIMEO seconds out of date. If you find that you need current
129 * attributes this could be forced by setting n_attrstamp to 0 before
130 * the VOP_GETATTR() call.
131 */
132
133 if ((nmp->nm_flag & NFSMNT_NQNFS) == 0 && vp->v_type != VLNK) {
134 error = nfs_flushstalebuf(vp, cred, p,
135 NFS_FLUSHSTALEBUF_MYWRITE);
136 if (error)
137 return error;
138 }
139
140 do {
141 #ifndef NFS_V2_ONLY
142 /*
143 * Get a valid lease. If cached data is stale, flush it.
144 */
145 if (nmp->nm_flag & NFSMNT_NQNFS) {
146 if (NQNFS_CKINVALID(vp, np, ND_READ)) {
147 do {
148 error = nqnfs_getlease(vp, ND_READ, cred, p);
149 } while (error == NQNFS_EXPIRED);
150 if (error)
151 return (error);
152 if (np->n_lrev != np->n_brev ||
153 (np->n_flag & NQNFSNONCACHE) ||
154 ((np->n_flag & NMODIFIED) && vp->v_type == VDIR)) {
155 if (vp->v_type == VDIR) {
156 nfs_invaldircache(vp, 0);
157 }
158 error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1);
159 if (error)
160 return (error);
161 np->n_brev = np->n_lrev;
162 }
163 } else if (vp->v_type == VDIR && (np->n_flag & NMODIFIED)) {
164 nfs_invaldircache(vp, 0);
165 error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1);
166 if (error)
167 return (error);
168 }
169 }
170 #endif
171 /*
172 * Don't cache symlinks.
173 */
174 if (np->n_flag & NQNFSNONCACHE
175 || ((vp->v_flag & VROOT) && vp->v_type == VLNK)) {
176 switch (vp->v_type) {
177 case VREG:
178 return (nfs_readrpc(vp, uio));
179 case VLNK:
180 return (nfs_readlinkrpc(vp, uio, cred));
181 case VDIR:
182 break;
183 default:
184 printf(" NQNFSNONCACHE: type %x unexpected\n",
185 vp->v_type);
186 };
187 }
188 baddr = (caddr_t)0;
189 switch (vp->v_type) {
190 case VREG:
191 nfsstats.biocache_reads++;
192
193 error = 0;
194 while (uio->uio_resid > 0) {
195 void *win;
196 int flags;
197 vsize_t bytelen;
198
199 nfs_delayedtruncate(vp);
200 if (np->n_size <= uio->uio_offset) {
201 break;
202 }
203 bytelen =
204 MIN(np->n_size - uio->uio_offset, uio->uio_resid);
205 win = ubc_alloc(&vp->v_uobj, uio->uio_offset,
206 &bytelen, UBC_READ);
207 error = uiomove(win, bytelen, uio);
208 flags = UBC_WANT_UNMAP(vp) ? UBC_UNMAP : 0;
209 ubc_release(win, flags);
210 if (error) {
211 /*
212 * XXXkludge
213 * the file has been truncated on the server.
214 * there isn't much we can do.
215 */
216 if (uio->uio_offset >= np->n_size) {
217 /* end of file */
218 error = 0;
219 } else {
220 break;
221 }
222 }
223 }
224 break;
225
226 case VLNK:
227 nfsstats.biocache_readlinks++;
228 bp = nfs_getcacheblk(vp, (daddr_t)0, NFS_MAXPATHLEN, p);
229 if (!bp)
230 return (EINTR);
231 if ((bp->b_flags & B_DONE) == 0) {
232 bp->b_flags |= B_READ;
233 error = nfs_doio(bp, p);
234 if (error) {
235 brelse(bp);
236 return (error);
237 }
238 }
239 n = MIN(uio->uio_resid, NFS_MAXPATHLEN - bp->b_resid);
240 got_buf = 1;
241 on = 0;
242 break;
243 case VDIR:
244 diragain:
245 nfsstats.biocache_readdirs++;
246 ndp = nfs_searchdircache(vp, uio->uio_offset,
247 (nmp->nm_flag & NFSMNT_XLATECOOKIE), 0);
248 if (!ndp) {
249 /*
250 * We've been handed a cookie that is not
251 * in the cache. If we're not translating
252 * 32 <-> 64, it may be a value that was
253 * flushed out of the cache because it grew
254 * too big. Let the server judge if it's
255 * valid or not. In the translation case,
256 * we have no way of validating this value,
257 * so punt.
258 */
259 if (nmp->nm_flag & NFSMNT_XLATECOOKIE)
260 return (EINVAL);
261 ndp = nfs_enterdircache(vp, uio->uio_offset,
262 uio->uio_offset, 0, 0);
263 }
264
265 if (NFS_EOFVALID(np) &&
266 ndp->dc_cookie == np->n_direofoffset) {
267 nfs_putdircache(np, ndp);
268 nfsstats.direofcache_hits++;
269 return (0);
270 }
271
272 bp = nfs_getcacheblk(vp, NFSDC_BLKNO(ndp), NFS_DIRBLKSIZ, p);
273 if (!bp)
274 return (EINTR);
275 if ((bp->b_flags & B_DONE) == 0) {
276 bp->b_flags |= B_READ;
277 bp->b_dcookie = ndp->dc_blkcookie;
278 error = nfs_doio(bp, p);
279 if (error) {
280 /*
281 * Yuck! The directory has been modified on the
282 * server. Punt and let the userland code
283 * deal with it.
284 */
285 nfs_putdircache(np, ndp);
286 brelse(bp);
287 if (error == NFSERR_BAD_COOKIE) {
288 nfs_invaldircache(vp, 0);
289 nfs_vinvalbuf(vp, 0, cred, p, 1);
290 error = EINVAL;
291 }
292 return (error);
293 }
294 }
295
296 /*
297 * Just return if we hit EOF right away with this
298 * block. Always check here, because direofoffset
299 * may have been set by an nfsiod since the last
300 * check.
301 *
302 * also, empty block implies EOF.
303 */
304
305 if (bp->b_bcount == bp->b_resid ||
306 (NFS_EOFVALID(np) &&
307 ndp->dc_blkcookie == np->n_direofoffset)) {
308 KASSERT(bp->b_bcount != bp->b_resid ||
309 ndp->dc_blkcookie == bp->b_dcookie);
310 nfs_putdircache(np, ndp);
311 bp->b_flags |= B_NOCACHE;
312 brelse(bp);
313 return 0;
314 }
315
316 /*
317 * Find the entry we were looking for in the block.
318 */
319
320 en = ndp->dc_entry;
321
322 pdp = dp = (struct dirent *)bp->b_data;
323 edp = bp->b_data + bp->b_bcount - bp->b_resid;
324 enn = 0;
325 while (enn < en && (caddr_t)dp < edp) {
326 pdp = dp;
327 dp = (struct dirent *)((caddr_t)dp + dp->d_reclen);
328 enn++;
329 }
330
331 /*
332 * If the entry number was bigger than the number of
333 * entries in the block, or the cookie of the previous
334 * entry doesn't match, the directory cache is
335 * stale. Flush it and try again (i.e. go to
336 * the server).
337 */
338 if ((caddr_t)dp >= edp || (caddr_t)dp + dp->d_reclen > edp ||
339 (en > 0 && NFS_GETCOOKIE(pdp) != ndp->dc_cookie)) {
340 #ifdef DEBUG
341 printf("invalid cache: %p %p %p off %lx %lx\n",
342 pdp, dp, edp,
343 (unsigned long)uio->uio_offset,
344 (unsigned long)NFS_GETCOOKIE(pdp));
345 #endif
346 nfs_putdircache(np, ndp);
347 brelse(bp);
348 nfs_invaldircache(vp, 0);
349 nfs_vinvalbuf(vp, 0, cred, p, 0);
350 goto diragain;
351 }
352
353 on = (caddr_t)dp - bp->b_data;
354
355 /*
356 * Cache all entries that may be exported to the
357 * user, as they may be thrown back at us. The
358 * NFSBIO_CACHECOOKIES flag indicates that all
359 * entries are being 'exported', so cache them all.
360 */
361
362 if (en == 0 && pdp == dp) {
363 dp = (struct dirent *)
364 ((caddr_t)dp + dp->d_reclen);
365 enn++;
366 }
367
368 if (uio->uio_resid < (bp->b_bcount - bp->b_resid - on)) {
369 n = uio->uio_resid;
370 enough = 1;
371 } else
372 n = bp->b_bcount - bp->b_resid - on;
373
374 ep = bp->b_data + on + n;
375
376 /*
377 * Find last complete entry to copy, caching entries
378 * (if requested) as we go.
379 */
380
381 while ((caddr_t)dp < ep && (caddr_t)dp + dp->d_reclen <= ep) {
382 if (cflag & NFSBIO_CACHECOOKIES) {
383 nndp = nfs_enterdircache(vp, NFS_GETCOOKIE(pdp),
384 ndp->dc_blkcookie, enn, bp->b_lblkno);
385 if (nmp->nm_flag & NFSMNT_XLATECOOKIE) {
386 NFS_STASHCOOKIE32(pdp,
387 nndp->dc_cookie32);
388 }
389 nfs_putdircache(np, nndp);
390 }
391 pdp = dp;
392 dp = (struct dirent *)((caddr_t)dp + dp->d_reclen);
393 enn++;
394 }
395 nfs_putdircache(np, ndp);
396
397 /*
398 * If the last requested entry was not the last in the
399 * buffer (happens if NFS_DIRFRAGSIZ < NFS_DIRBLKSIZ),
400 * cache the cookie of the last requested one, and
401 * set of the offset to it.
402 */
403
404 if ((on + n) < bp->b_bcount - bp->b_resid) {
405 curoff = NFS_GETCOOKIE(pdp);
406 nndp = nfs_enterdircache(vp, curoff, ndp->dc_blkcookie,
407 enn, bp->b_lblkno);
408 if (nmp->nm_flag & NFSMNT_XLATECOOKIE) {
409 NFS_STASHCOOKIE32(pdp, nndp->dc_cookie32);
410 curoff = nndp->dc_cookie32;
411 }
412 nfs_putdircache(np, nndp);
413 } else
414 curoff = bp->b_dcookie;
415
416 /*
417 * Always cache the entry for the next block,
418 * so that readaheads can use it.
419 */
420 nndp = nfs_enterdircache(vp, bp->b_dcookie, bp->b_dcookie, 0,0);
421 if (nmp->nm_flag & NFSMNT_XLATECOOKIE) {
422 if (curoff == bp->b_dcookie) {
423 NFS_STASHCOOKIE32(pdp, nndp->dc_cookie32);
424 curoff = nndp->dc_cookie32;
425 }
426 }
427
428 n = ((caddr_t)pdp + pdp->d_reclen) - (bp->b_data + on);
429
430 /*
431 * If not eof and read aheads are enabled, start one.
432 * (You need the current block first, so that you have the
433 * directory offset cookie of the next block.)
434 */
435 if (nfs_numasync > 0 && nmp->nm_readahead > 0 &&
436 !NFS_EOFVALID(np) && !(np->n_flag & NQNFSNONCACHE)) {
437 rabp = nfs_getcacheblk(vp, NFSDC_BLKNO(nndp),
438 NFS_DIRBLKSIZ, p);
439 if (rabp) {
440 if ((rabp->b_flags & (B_DONE | B_DELWRI)) == 0) {
441 rabp->b_dcookie = nndp->dc_cookie;
442 rabp->b_flags |= (B_READ | B_ASYNC);
443 if (nfs_asyncio(rabp)) {
444 rabp->b_flags |= B_INVAL;
445 brelse(rabp);
446 }
447 } else
448 brelse(rabp);
449 }
450 }
451 nfs_putdircache(np, nndp);
452 got_buf = 1;
453 break;
454 default:
455 printf(" nfsbioread: type %x unexpected\n",vp->v_type);
456 break;
457 }
458
459 if (n > 0) {
460 if (!baddr)
461 baddr = bp->b_data;
462 error = uiomove(baddr + on, (int)n, uio);
463 }
464 switch (vp->v_type) {
465 case VREG:
466 break;
467 case VLNK:
468 n = 0;
469 break;
470 case VDIR:
471 if (np->n_flag & NQNFSNONCACHE)
472 bp->b_flags |= B_INVAL;
473 uio->uio_offset = curoff;
474 if (enough)
475 n = 0;
476 break;
477 default:
478 printf(" nfsbioread: type %x unexpected\n",vp->v_type);
479 }
480 if (got_buf)
481 brelse(bp);
482 } while (error == 0 && uio->uio_resid > 0 && n > 0);
483 return (error);
484 }
485
486 /*
487 * Vnode op for write using bio
488 */
489 int
490 nfs_write(v)
491 void *v;
492 {
493 struct vop_write_args /* {
494 struct vnode *a_vp;
495 struct uio *a_uio;
496 int a_ioflag;
497 struct ucred *a_cred;
498 } */ *ap = v;
499 struct uio *uio = ap->a_uio;
500 struct proc *p = uio->uio_procp;
501 struct vnode *vp = ap->a_vp;
502 struct nfsnode *np = VTONFS(vp);
503 struct ucred *cred = ap->a_cred;
504 struct vattr vattr;
505 struct nfsmount *nmp = VFSTONFS(vp->v_mount);
506 void *win;
507 voff_t oldoff, origoff;
508 vsize_t bytelen;
509 int flags, error = 0;
510 int ioflag = ap->a_ioflag;
511 int extended = 0, wrotedata = 0;
512
513 #ifdef DIAGNOSTIC
514 if (uio->uio_rw != UIO_WRITE)
515 panic("nfs_write mode");
516 if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != curproc)
517 panic("nfs_write proc");
518 #endif
519 if (vp->v_type != VREG)
520 return (EIO);
521 if (np->n_flag & NWRITEERR) {
522 np->n_flag &= ~NWRITEERR;
523 return (np->n_error);
524 }
525 #ifndef NFS_V2_ONLY
526 if ((nmp->nm_flag & NFSMNT_NFSV3) &&
527 !(nmp->nm_iflag & NFSMNT_GOTFSINFO))
528 (void)nfs_fsinfo(nmp, vp, cred, p);
529 #endif
530 if (ioflag & (IO_APPEND | IO_SYNC)) {
531 if (np->n_flag & NMODIFIED) {
532 NFS_INVALIDATE_ATTRCACHE(np);
533 error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1);
534 if (error)
535 return (error);
536 }
537 if (ioflag & IO_APPEND) {
538 NFS_INVALIDATE_ATTRCACHE(np);
539 error = VOP_GETATTR(vp, &vattr, cred, p);
540 if (error)
541 return (error);
542 uio->uio_offset = np->n_size;
543 }
544 }
545 if (uio->uio_offset < 0)
546 return (EINVAL);
547 if ((uio->uio_offset + uio->uio_resid) > nmp->nm_maxfilesize)
548 return (EFBIG);
549 if (uio->uio_resid == 0)
550 return (0);
551 /*
552 * Maybe this should be above the vnode op call, but so long as
553 * file servers have no limits, i don't think it matters
554 */
555 if (p && uio->uio_offset + uio->uio_resid >
556 p->p_rlimit[RLIMIT_FSIZE].rlim_cur) {
557 psignal(p, SIGXFSZ);
558 return (EFBIG);
559 }
560
561 if ((np->n_flag & NQNFSNONCACHE) && uio->uio_iovcnt == 1) {
562 int iomode = NFSV3WRITE_FILESYNC;
563 boolean_t stalewriteverf = FALSE;
564
565 lockmgr(&nmp->nm_writeverflock, LK_SHARED, NULL);
566 error = nfs_writerpc(vp, uio, &iomode, FALSE, &stalewriteverf);
567 lockmgr(&nmp->nm_writeverflock, LK_RELEASE, NULL);
568 if (stalewriteverf)
569 nfs_clearcommit(vp->v_mount);
570 return (error);
571 }
572
573 origoff = uio->uio_offset;
574 do {
575 boolean_t extending; /* if we are extending whole pages */
576 u_quad_t oldsize;
577 oldoff = uio->uio_offset;
578 bytelen = uio->uio_resid;
579
580 #ifndef NFS_V2_ONLY
581 /*
582 * Check for a valid write lease.
583 */
584 if ((nmp->nm_flag & NFSMNT_NQNFS) &&
585 NQNFS_CKINVALID(vp, np, ND_WRITE)) {
586 do {
587 error = nqnfs_getlease(vp, ND_WRITE, cred, p);
588 } while (error == NQNFS_EXPIRED);
589 if (error)
590 return (error);
591 if (np->n_lrev != np->n_brev ||
592 (np->n_flag & NQNFSNONCACHE)) {
593 error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1);
594 if (error)
595 return (error);
596 np->n_brev = np->n_lrev;
597 }
598 }
599 #endif
600 nfsstats.biocache_writes++;
601
602 oldsize = np->n_size;
603 np->n_flag |= NMODIFIED;
604 if (np->n_size < uio->uio_offset + bytelen) {
605 np->n_size = uio->uio_offset + bytelen;
606 }
607 extending = ((uio->uio_offset & PAGE_MASK) == 0 &&
608 (bytelen & PAGE_MASK) == 0 &&
609 uio->uio_offset >= vp->v_size);
610 win = ubc_alloc(&vp->v_uobj, uio->uio_offset, &bytelen,
611 UBC_WRITE | (extending ? UBC_FAULTBUSY : 0));
612 error = uiomove(win, bytelen, uio);
613 flags = UBC_WANT_UNMAP(vp) ? UBC_UNMAP : 0;
614 ubc_release(win, flags);
615 if (error) {
616 if (extending) {
617 /*
618 * backout size and free pages past eof.
619 */
620 np->n_size = oldsize;
621 simple_lock(&vp->v_interlock);
622 (void)VOP_PUTPAGES(vp, round_page(vp->v_size),
623 0, PGO_SYNCIO | PGO_FREE);
624 }
625 break;
626 }
627 wrotedata = 1;
628
629 /*
630 * update UVM's notion of the size now that we've
631 * copied the data into the vnode's pages.
632 */
633
634 if (vp->v_size < uio->uio_offset) {
635 uvm_vnp_setsize(vp, uio->uio_offset);
636 extended = 1;
637 }
638
639 if ((oldoff & ~(nmp->nm_wsize - 1)) !=
640 (uio->uio_offset & ~(nmp->nm_wsize - 1))) {
641 simple_lock(&vp->v_interlock);
642 error = VOP_PUTPAGES(vp,
643 trunc_page(oldoff & ~(nmp->nm_wsize - 1)),
644 round_page((uio->uio_offset + nmp->nm_wsize - 1) &
645 ~(nmp->nm_wsize - 1)), PGO_CLEANIT);
646 }
647 } while (uio->uio_resid > 0);
648 if (wrotedata)
649 VN_KNOTE(vp, NOTE_WRITE | (extended ? NOTE_EXTEND : 0));
650 if ((np->n_flag & NQNFSNONCACHE) || (ioflag & IO_SYNC)) {
651 simple_lock(&vp->v_interlock);
652 error = VOP_PUTPAGES(vp,
653 trunc_page(origoff & ~(nmp->nm_wsize - 1)),
654 round_page((uio->uio_offset + nmp->nm_wsize - 1) &
655 ~(nmp->nm_wsize - 1)),
656 PGO_CLEANIT | PGO_SYNCIO);
657 }
658 return error;
659 }
660
661 /*
662 * Get an nfs cache block.
663 * Allocate a new one if the block isn't currently in the cache
664 * and return the block marked busy. If the calling process is
665 * interrupted by a signal for an interruptible mount point, return
666 * NULL.
667 */
668 struct buf *
669 nfs_getcacheblk(vp, bn, size, p)
670 struct vnode *vp;
671 daddr_t bn;
672 int size;
673 struct proc *p;
674 {
675 struct buf *bp;
676 struct nfsmount *nmp = VFSTONFS(vp->v_mount);
677
678 if (nmp->nm_flag & NFSMNT_INT) {
679 bp = getblk(vp, bn, size, PCATCH, 0);
680 while (bp == NULL) {
681 if (nfs_sigintr(nmp, NULL, p))
682 return (NULL);
683 bp = getblk(vp, bn, size, 0, 2 * hz);
684 }
685 } else
686 bp = getblk(vp, bn, size, 0, 0);
687 return (bp);
688 }
689
690 /*
691 * Flush and invalidate all dirty buffers. If another process is already
692 * doing the flush, just wait for completion.
693 */
694 int
695 nfs_vinvalbuf(vp, flags, cred, p, intrflg)
696 struct vnode *vp;
697 int flags;
698 struct ucred *cred;
699 struct proc *p;
700 int intrflg;
701 {
702 struct nfsnode *np = VTONFS(vp);
703 struct nfsmount *nmp = VFSTONFS(vp->v_mount);
704 int error = 0, slpflag, slptimeo;
705
706 if ((nmp->nm_flag & NFSMNT_INT) == 0)
707 intrflg = 0;
708 if (intrflg) {
709 slpflag = PCATCH;
710 slptimeo = 2 * hz;
711 } else {
712 slpflag = 0;
713 slptimeo = 0;
714 }
715 /*
716 * First wait for any other process doing a flush to complete.
717 */
718 simple_lock(&vp->v_interlock);
719 while (np->n_flag & NFLUSHINPROG) {
720 np->n_flag |= NFLUSHWANT;
721 error = ltsleep(&np->n_flag, PRIBIO + 2, "nfsvinval",
722 slptimeo, &vp->v_interlock);
723 if (error && intrflg && nfs_sigintr(nmp, NULL, p)) {
724 simple_unlock(&vp->v_interlock);
725 return EINTR;
726 }
727 }
728
729 /*
730 * Now, flush as required.
731 */
732 np->n_flag |= NFLUSHINPROG;
733 simple_unlock(&vp->v_interlock);
734 error = vinvalbuf(vp, flags, cred, p, slpflag, 0);
735 while (error) {
736 if (intrflg && nfs_sigintr(nmp, NULL, p)) {
737 error = EINTR;
738 break;
739 }
740 error = vinvalbuf(vp, flags, cred, p, 0, slptimeo);
741 }
742 simple_lock(&vp->v_interlock);
743 if (error == 0)
744 np->n_flag &= ~NMODIFIED;
745 np->n_flag &= ~NFLUSHINPROG;
746 if (np->n_flag & NFLUSHWANT) {
747 np->n_flag &= ~NFLUSHWANT;
748 wakeup(&np->n_flag);
749 }
750 simple_unlock(&vp->v_interlock);
751 return error;
752 }
753
754 /*
755 * nfs_flushstalebuf: flush cache if it's stale.
756 *
757 * => caller shouldn't own any pages or buffers which belong to the vnode.
758 */
759
760 int
761 nfs_flushstalebuf(struct vnode *vp, struct ucred *cred, struct proc *p,
762 int flags)
763 {
764 struct nfsnode *np = VTONFS(vp);
765 struct vattr vattr;
766 int error;
767
768 if (np->n_flag & NMODIFIED) {
769 if ((flags & NFS_FLUSHSTALEBUF_MYWRITE) == 0
770 || vp->v_type != VREG) {
771 error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1);
772 if (error)
773 return error;
774 if (vp->v_type == VDIR) {
775 nfs_invaldircache(vp, 0);
776 }
777 } else {
778 /*
779 * XXX assuming writes are ours.
780 */
781 }
782 NFS_INVALIDATE_ATTRCACHE(np);
783 error = VOP_GETATTR(vp, &vattr, cred, p);
784 if (error)
785 return error;
786 np->n_mtime = vattr.va_mtime;
787 } else {
788 error = VOP_GETATTR(vp, &vattr, cred, p);
789 if (error)
790 return error;
791 if (timespeccmp(&np->n_mtime, &vattr.va_mtime, !=)) {
792 if (vp->v_type == VDIR) {
793 nfs_invaldircache(vp, 0);
794 }
795 error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1);
796 if (error)
797 return error;
798 np->n_mtime = vattr.va_mtime;
799 }
800 }
801
802 return error;
803 }
804
805 /*
806 * Initiate asynchronous I/O. Return an error if no nfsiods are available.
807 * This is mainly to avoid queueing async I/O requests when the nfsiods
808 * are all hung on a dead server.
809 */
810
811 int
812 nfs_asyncio(bp)
813 struct buf *bp;
814 {
815 int i;
816 struct nfsmount *nmp;
817 int gotiod, slpflag = 0, slptimeo = 0, error;
818
819 if (nfs_numasync == 0)
820 return (EIO);
821
822 nmp = VFSTONFS(bp->b_vp->v_mount);
823 again:
824 if (nmp->nm_flag & NFSMNT_INT)
825 slpflag = PCATCH;
826 gotiod = FALSE;
827
828 /*
829 * Find a free iod to process this request.
830 */
831
832 for (i = 0; i < NFS_MAXASYNCDAEMON; i++) {
833 struct nfs_iod *iod = &nfs_asyncdaemon[i];
834
835 simple_lock(&iod->nid_slock);
836 if (iod->nid_want) {
837 /*
838 * Found one, so wake it up and tell it which
839 * mount to process.
840 */
841 iod->nid_want = NULL;
842 iod->nid_mount = nmp;
843 wakeup(&iod->nid_want);
844 simple_lock(&nmp->nm_slock);
845 simple_unlock(&iod->nid_slock);
846 nmp->nm_bufqiods++;
847 gotiod = TRUE;
848 break;
849 }
850 simple_unlock(&iod->nid_slock);
851 }
852
853 /*
854 * If none are free, we may already have an iod working on this mount
855 * point. If so, it will process our request.
856 */
857
858 if (!gotiod) {
859 simple_lock(&nmp->nm_slock);
860 if (nmp->nm_bufqiods > 0)
861 gotiod = TRUE;
862 }
863
864 LOCK_ASSERT(simple_lock_held(&nmp->nm_slock));
865
866 /*
867 * If we have an iod which can process the request, then queue
868 * the buffer. However, even if we have an iod, do not initiate
869 * queue cleaning if curproc is the pageout daemon. if the NFS mount
870 * is via local loopback, we may put curproc (pagedaemon) to sleep
871 * waiting for the writes to complete. But the server (ourself)
872 * may block the write, waiting for its (ie., our) pagedaemon
873 * to produce clean pages to handle the write: deadlock.
874 * XXX: start non-loopback mounts straight away? If "lots free",
875 * let pagedaemon start loopback writes anyway?
876 */
877 if (gotiod) {
878
879 /*
880 * Ensure that the queue never grows too large.
881 */
882 if (curproc == uvm.pagedaemon_proc) {
883 /* Enque for later, to avoid free-page deadlock */
884 (void) 0;
885 } else while (nmp->nm_bufqlen >= 2*nfs_numasync) {
886 nmp->nm_bufqwant = TRUE;
887 error = ltsleep(&nmp->nm_bufq,
888 slpflag | PRIBIO | PNORELOCK,
889 "nfsaio", slptimeo, &nmp->nm_slock);
890 if (error) {
891 if (nfs_sigintr(nmp, NULL, curproc))
892 return (EINTR);
893 if (slpflag == PCATCH) {
894 slpflag = 0;
895 slptimeo = 2 * hz;
896 }
897 }
898
899 /*
900 * We might have lost our iod while sleeping,
901 * so check and loop if nescessary.
902 */
903
904 if (nmp->nm_bufqiods == 0)
905 goto again;
906
907 simple_lock(&nmp->nm_slock);
908 }
909 TAILQ_INSERT_TAIL(&nmp->nm_bufq, bp, b_freelist);
910 nmp->nm_bufqlen++;
911 simple_unlock(&nmp->nm_slock);
912 return (0);
913 }
914 simple_unlock(&nmp->nm_slock);
915
916 /*
917 * All the iods are busy on other mounts, so return EIO to
918 * force the caller to process the i/o synchronously.
919 */
920
921 return (EIO);
922 }
923
924 /*
925 * nfs_doio for read.
926 */
927 static int
928 nfs_doio_read(bp, uiop)
929 struct buf *bp;
930 struct uio *uiop;
931 {
932 struct vnode *vp = bp->b_vp;
933 struct nfsnode *np = VTONFS(vp);
934 struct nfsmount *nmp = VFSTONFS(vp->v_mount);
935 int error = 0;
936
937 uiop->uio_rw = UIO_READ;
938 switch (vp->v_type) {
939 case VREG:
940 nfsstats.read_bios++;
941 error = nfs_readrpc(vp, uiop);
942 if (!error && uiop->uio_resid) {
943 int diff, len;
944
945 /*
946 * If uio_resid > 0, there is a hole in the file and
947 * no writes after the hole have been pushed to
948 * the server yet or the file has been truncated
949 * on the server.
950 * Just zero fill the rest of the valid area.
951 */
952
953 KASSERT(vp->v_size >=
954 uiop->uio_offset + uiop->uio_resid);
955 diff = bp->b_bcount - uiop->uio_resid;
956 len = uiop->uio_resid;
957 memset((char *)bp->b_data + diff, 0, len);
958 }
959 if (uiop->uio_procp && (vp->v_flag & VTEXT) &&
960 (((nmp->nm_flag & NFSMNT_NQNFS) &&
961 NQNFS_CKINVALID(vp, np, ND_READ) &&
962 np->n_lrev != np->n_brev) ||
963 (!(nmp->nm_flag & NFSMNT_NQNFS) &&
964 timespeccmp(&np->n_mtime, &np->n_vattr->va_mtime, !=)))) {
965 uprintf("Process killed due to "
966 "text file modification\n");
967 psignal(uiop->uio_procp, SIGKILL);
968 #if 0 /* XXX NJWLWP */
969 uiop->uio_procp->p_holdcnt++;
970 #endif
971 }
972 break;
973 case VLNK:
974 KASSERT(uiop->uio_offset == (off_t)0);
975 nfsstats.readlink_bios++;
976 error = nfs_readlinkrpc(vp, uiop, curproc->p_ucred);
977 break;
978 case VDIR:
979 nfsstats.readdir_bios++;
980 uiop->uio_offset = bp->b_dcookie;
981 #ifndef NFS_V2_ONLY
982 if (nmp->nm_flag & NFSMNT_RDIRPLUS) {
983 error = nfs_readdirplusrpc(vp, uiop, np->n_rcred);
984 if (error == NFSERR_NOTSUPP)
985 nmp->nm_flag &= ~NFSMNT_RDIRPLUS;
986 }
987 #else
988 nmp->nm_flag &= ~NFSMNT_RDIRPLUS;
989 #endif
990 if ((nmp->nm_flag & NFSMNT_RDIRPLUS) == 0)
991 error = nfs_readdirrpc(vp, uiop, np->n_rcred);
992 if (!error) {
993 bp->b_dcookie = uiop->uio_offset;
994 }
995 break;
996 default:
997 printf("nfs_doio: type %x unexpected\n", vp->v_type);
998 break;
999 }
1000 if (error) {
1001 bp->b_flags |= B_ERROR;
1002 bp->b_error = error;
1003 }
1004 return error;
1005 }
1006
1007 /*
1008 * nfs_doio for write.
1009 */
1010 static int
1011 nfs_doio_write(bp, uiop)
1012 struct buf *bp;
1013 struct uio *uiop;
1014 {
1015 struct vnode *vp = bp->b_vp;
1016 struct nfsnode *np = VTONFS(vp);
1017 struct nfsmount *nmp = VFSTONFS(vp->v_mount);
1018 int iomode;
1019 boolean_t stalewriteverf = FALSE;
1020 int i, npages = (bp->b_bcount + PAGE_SIZE - 1) >> PAGE_SHIFT;
1021 struct vm_page *pgs[npages];
1022 #ifndef NFS_V2_ONLY
1023 boolean_t needcommit = TRUE; /* need only COMMIT RPC */
1024 #else
1025 boolean_t needcommit = FALSE; /* need only COMMIT RPC */
1026 #endif
1027 boolean_t pageprotected;
1028 struct uvm_object *uobj = &vp->v_uobj;
1029 int error;
1030 off_t off, cnt;
1031
1032 if ((bp->b_flags & B_ASYNC) != 0 && NFS_ISV3(vp)) {
1033 iomode = NFSV3WRITE_UNSTABLE;
1034 } else {
1035 iomode = NFSV3WRITE_FILESYNC;
1036 }
1037
1038 #ifndef NFS_V2_ONLY
1039 again:
1040 #endif
1041 lockmgr(&nmp->nm_writeverflock, LK_SHARED, NULL);
1042
1043 for (i = 0; i < npages; i++) {
1044 pgs[i] = uvm_pageratop((vaddr_t)bp->b_data + (i << PAGE_SHIFT));
1045 if (pgs[i]->uobject == uobj &&
1046 pgs[i]->offset == uiop->uio_offset + (i << PAGE_SHIFT)) {
1047 KASSERT(pgs[i]->flags & PG_BUSY);
1048 /*
1049 * this page belongs to our object.
1050 */
1051 simple_lock(&uobj->vmobjlock);
1052 /*
1053 * write out the page stably if it's about to
1054 * be released because we can't resend it
1055 * on the server crash.
1056 *
1057 * XXX assuming PG_RELEASE|PG_PAGEOUT won't be
1058 * changed until unbusy the page.
1059 */
1060 if (pgs[i]->flags & (PG_RELEASED|PG_PAGEOUT))
1061 iomode = NFSV3WRITE_FILESYNC;
1062 /*
1063 * if we met a page which hasn't been sent yet,
1064 * we need do WRITE RPC.
1065 */
1066 if ((pgs[i]->flags & PG_NEEDCOMMIT) == 0)
1067 needcommit = FALSE;
1068 simple_unlock(&uobj->vmobjlock);
1069 } else {
1070 iomode = NFSV3WRITE_FILESYNC;
1071 needcommit = FALSE;
1072 }
1073 }
1074 if (!needcommit && iomode == NFSV3WRITE_UNSTABLE) {
1075 simple_lock(&uobj->vmobjlock);
1076 for (i = 0; i < npages; i++) {
1077 pgs[i]->flags |= PG_NEEDCOMMIT | PG_RDONLY;
1078 pmap_page_protect(pgs[i], VM_PROT_READ);
1079 }
1080 simple_unlock(&uobj->vmobjlock);
1081 pageprotected = TRUE; /* pages can't be modified during i/o. */
1082 } else
1083 pageprotected = FALSE;
1084
1085 /*
1086 * Send the data to the server if necessary,
1087 * otherwise just send a commit rpc.
1088 */
1089 #ifndef NFS_V2_ONLY
1090 if (needcommit) {
1091
1092 /*
1093 * If the buffer is in the range that we already committed,
1094 * there's nothing to do.
1095 *
1096 * If it's in the range that we need to commit, push the
1097 * whole range at once, otherwise only push the buffer.
1098 * In both these cases, acquire the commit lock to avoid
1099 * other processes modifying the range.
1100 */
1101
1102 off = uiop->uio_offset;
1103 cnt = bp->b_bcount;
1104 lockmgr(&np->n_commitlock, LK_EXCLUSIVE, NULL);
1105 if (!nfs_in_committed_range(vp, off, bp->b_bcount)) {
1106 boolean_t pushedrange;
1107 if (nfs_in_tobecommitted_range(vp, off, bp->b_bcount)) {
1108 pushedrange = TRUE;
1109 off = np->n_pushlo;
1110 cnt = np->n_pushhi - np->n_pushlo;
1111 } else {
1112 pushedrange = FALSE;
1113 }
1114 error = nfs_commit(vp, off, cnt, curproc);
1115 if (error == 0) {
1116 if (pushedrange) {
1117 nfs_merge_commit_ranges(vp);
1118 } else {
1119 nfs_add_committed_range(vp, off, cnt);
1120 }
1121 }
1122 } else {
1123 error = 0;
1124 }
1125 lockmgr(&np->n_commitlock, LK_RELEASE, NULL);
1126 lockmgr(&nmp->nm_writeverflock, LK_RELEASE, NULL);
1127 if (!error) {
1128 /*
1129 * pages are now on stable storage.
1130 */
1131 uiop->uio_resid = 0;
1132 simple_lock(&uobj->vmobjlock);
1133 for (i = 0; i < npages; i++) {
1134 pgs[i]->flags &= ~(PG_NEEDCOMMIT | PG_RDONLY);
1135 }
1136 simple_unlock(&uobj->vmobjlock);
1137 return 0;
1138 } else if (error == NFSERR_STALEWRITEVERF) {
1139 nfs_clearcommit(vp->v_mount);
1140 goto again;
1141 }
1142 if (error) {
1143 bp->b_flags |= B_ERROR;
1144 bp->b_error = np->n_error = error;
1145 np->n_flag |= NWRITEERR;
1146 }
1147 return error;
1148 }
1149 #endif
1150 off = uiop->uio_offset;
1151 cnt = bp->b_bcount;
1152 uiop->uio_rw = UIO_WRITE;
1153 nfsstats.write_bios++;
1154 error = nfs_writerpc(vp, uiop, &iomode, pageprotected, &stalewriteverf);
1155 #ifndef NFS_V2_ONLY
1156 if (!error && iomode == NFSV3WRITE_UNSTABLE) {
1157 /*
1158 * we need to commit pages later.
1159 */
1160 lockmgr(&np->n_commitlock, LK_EXCLUSIVE, NULL);
1161 nfs_add_tobecommitted_range(vp, off, cnt);
1162 /*
1163 * if there can be too many uncommitted pages, commit them now.
1164 */
1165 if (np->n_pushhi - np->n_pushlo > nfs_commitsize) {
1166 off = np->n_pushlo;
1167 cnt = nfs_commitsize >> 1;
1168 error = nfs_commit(vp, off, cnt, curproc);
1169 if (!error) {
1170 nfs_add_committed_range(vp, off, cnt);
1171 nfs_del_tobecommitted_range(vp, off, cnt);
1172 }
1173 if (error == NFSERR_STALEWRITEVERF) {
1174 stalewriteverf = TRUE;
1175 error = 0; /* it isn't a real error */
1176 }
1177 } else {
1178 /*
1179 * re-dirty pages so that they will be passed
1180 * to us later again.
1181 */
1182 simple_lock(&uobj->vmobjlock);
1183 for (i = 0; i < npages; i++) {
1184 pgs[i]->flags &= ~PG_CLEAN;
1185 }
1186 simple_unlock(&uobj->vmobjlock);
1187 }
1188 lockmgr(&np->n_commitlock, LK_RELEASE, NULL);
1189 } else
1190 #endif
1191 if (!error) {
1192 /*
1193 * pages are now on stable storage.
1194 */
1195 lockmgr(&np->n_commitlock, LK_EXCLUSIVE, NULL);
1196 nfs_del_committed_range(vp, off, cnt);
1197 lockmgr(&np->n_commitlock, LK_RELEASE, NULL);
1198 simple_lock(&uobj->vmobjlock);
1199 for (i = 0; i < npages; i++) {
1200 pgs[i]->flags &= ~(PG_NEEDCOMMIT | PG_RDONLY);
1201 }
1202 simple_unlock(&uobj->vmobjlock);
1203 } else {
1204 /*
1205 * we got an error.
1206 */
1207 bp->b_flags |= B_ERROR;
1208 bp->b_error = np->n_error = error;
1209 np->n_flag |= NWRITEERR;
1210 }
1211
1212 lockmgr(&nmp->nm_writeverflock, LK_RELEASE, NULL);
1213
1214 if (stalewriteverf) {
1215 nfs_clearcommit(vp->v_mount);
1216 }
1217 return error;
1218 }
1219
1220 /*
1221 * nfs_doio for B_PHYS.
1222 */
1223 static int
1224 nfs_doio_phys(bp, uiop)
1225 struct buf *bp;
1226 struct uio *uiop;
1227 {
1228 struct vnode *vp = bp->b_vp;
1229 int error;
1230
1231 uiop->uio_offset = ((off_t)bp->b_blkno) << DEV_BSHIFT;
1232 if (bp->b_flags & B_READ) {
1233 uiop->uio_rw = UIO_READ;
1234 nfsstats.read_physios++;
1235 error = nfs_readrpc(vp, uiop);
1236 } else {
1237 int iomode = NFSV3WRITE_DATASYNC;
1238 boolean_t stalewriteverf;
1239 struct nfsmount *nmp = VFSTONFS(vp->v_mount);
1240
1241 uiop->uio_rw = UIO_WRITE;
1242 nfsstats.write_physios++;
1243 lockmgr(&nmp->nm_writeverflock, LK_SHARED, NULL);
1244 error = nfs_writerpc(vp, uiop, &iomode, FALSE, &stalewriteverf);
1245 lockmgr(&nmp->nm_writeverflock, LK_RELEASE, NULL);
1246 if (stalewriteverf) {
1247 nfs_clearcommit(bp->b_vp->v_mount);
1248 }
1249 }
1250 if (error) {
1251 bp->b_flags |= B_ERROR;
1252 bp->b_error = error;
1253 }
1254 return error;
1255 }
1256
1257 /*
1258 * Do an I/O operation to/from a cache block. This may be called
1259 * synchronously or from an nfsiod.
1260 */
1261 int
1262 nfs_doio(bp, p)
1263 struct buf *bp;
1264 struct proc *p;
1265 {
1266 int error;
1267 struct uio uio;
1268 struct uio *uiop = &uio;
1269 struct iovec io;
1270 UVMHIST_FUNC("nfs_doio"); UVMHIST_CALLED(ubchist);
1271
1272 uiop->uio_iov = &io;
1273 uiop->uio_iovcnt = 1;
1274 uiop->uio_segflg = UIO_SYSSPACE;
1275 uiop->uio_procp = NULL;
1276 uiop->uio_offset = (((off_t)bp->b_blkno) << DEV_BSHIFT);
1277 io.iov_base = bp->b_data;
1278 io.iov_len = uiop->uio_resid = bp->b_bcount;
1279
1280 /*
1281 * Historically, paging was done with physio, but no more...
1282 */
1283 if (bp->b_flags & B_PHYS) {
1284 /*
1285 * ...though reading /dev/drum still gets us here.
1286 */
1287 error = nfs_doio_phys(bp, uiop);
1288 } else if (bp->b_flags & B_READ) {
1289 error = nfs_doio_read(bp, uiop);
1290 } else {
1291 error = nfs_doio_write(bp, uiop);
1292 }
1293 bp->b_resid = uiop->uio_resid;
1294 biodone(bp);
1295 return (error);
1296 }
1297
1298 /*
1299 * Vnode op for VM getpages.
1300 */
1301
1302 int
1303 nfs_getpages(v)
1304 void *v;
1305 {
1306 struct vop_getpages_args /* {
1307 struct vnode *a_vp;
1308 voff_t a_offset;
1309 struct vm_page **a_m;
1310 int *a_count;
1311 int a_centeridx;
1312 vm_prot_t a_access_type;
1313 int a_advice;
1314 int a_flags;
1315 } */ *ap = v;
1316
1317 struct vnode *vp = ap->a_vp;
1318 struct uvm_object *uobj = &vp->v_uobj;
1319 struct nfsnode *np = VTONFS(vp);
1320 const int npages = *ap->a_count;
1321 struct vm_page *pg, **pgs, *opgs[npages];
1322 off_t origoffset, len;
1323 int i, error;
1324 boolean_t v3 = NFS_ISV3(vp);
1325 boolean_t write = (ap->a_access_type & VM_PROT_WRITE) != 0;
1326 boolean_t locked = (ap->a_flags & PGO_LOCKED) != 0;
1327
1328 /*
1329 * call the genfs code to get the pages. `pgs' may be NULL
1330 * when doing read-ahead.
1331 */
1332
1333 pgs = ap->a_m;
1334 if (write && locked && v3) {
1335 KASSERT(pgs != NULL);
1336 #ifdef DEBUG
1337
1338 /*
1339 * If PGO_LOCKED is set, real pages shouldn't exists
1340 * in the array.
1341 */
1342
1343 for (i = 0; i < npages; i++)
1344 KDASSERT(pgs[i] == NULL || pgs[i] == PGO_DONTCARE);
1345 #endif
1346 memcpy(opgs, pgs, npages * sizeof(struct vm_pages *));
1347 }
1348 error = genfs_getpages(v);
1349 if (error) {
1350 return (error);
1351 }
1352
1353 /*
1354 * for read faults where the nfs node is not yet marked NMODIFIED,
1355 * set PG_RDONLY on the pages so that we come back here if someone
1356 * tries to modify later via the mapping that will be entered for
1357 * this fault.
1358 */
1359
1360 if (!write && (np->n_flag & NMODIFIED) == 0 && pgs != NULL) {
1361 if (!locked) {
1362 simple_lock(&uobj->vmobjlock);
1363 }
1364 for (i = 0; i < npages; i++) {
1365 pg = pgs[i];
1366 if (pg == NULL || pg == PGO_DONTCARE) {
1367 continue;
1368 }
1369 pg->flags |= PG_RDONLY;
1370 }
1371 if (!locked) {
1372 simple_unlock(&uobj->vmobjlock);
1373 }
1374 }
1375 if (!write) {
1376 return (0);
1377 }
1378
1379 /*
1380 * this is a write fault, update the commit info.
1381 */
1382
1383 origoffset = ap->a_offset;
1384 len = npages << PAGE_SHIFT;
1385
1386 if (v3) {
1387 error = lockmgr(&np->n_commitlock,
1388 LK_EXCLUSIVE | (locked ? LK_NOWAIT : 0), NULL);
1389 if (error) {
1390 KASSERT(locked != 0);
1391
1392 /*
1393 * Since PGO_LOCKED is set, we need to unbusy
1394 * all pages fetched by genfs_getpages() above,
1395 * tell the caller that there are no pages
1396 * available and put back original pgs array.
1397 */
1398
1399 uvm_lock_pageq();
1400 uvm_page_unbusy(pgs, npages);
1401 uvm_unlock_pageq();
1402 *ap->a_count = 0;
1403 memcpy(pgs, opgs,
1404 npages * sizeof(struct vm_pages *));
1405 return (error);
1406 }
1407 nfs_del_committed_range(vp, origoffset, len);
1408 nfs_del_tobecommitted_range(vp, origoffset, len);
1409 }
1410 np->n_flag |= NMODIFIED;
1411 if (!locked) {
1412 simple_lock(&uobj->vmobjlock);
1413 }
1414 for (i = 0; i < npages; i++) {
1415 pg = pgs[i];
1416 if (pg == NULL || pg == PGO_DONTCARE) {
1417 continue;
1418 }
1419 pg->flags &= ~(PG_NEEDCOMMIT | PG_RDONLY);
1420 }
1421 if (!locked) {
1422 simple_unlock(&uobj->vmobjlock);
1423 }
1424 if (v3) {
1425 lockmgr(&np->n_commitlock, LK_RELEASE, NULL);
1426 }
1427 return (0);
1428 }
Cache object: ef31e318f57edbb62537bb97b107938d
|