![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nfs_bio.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / nfs|
Return to nfs_bio.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / nfs |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
26: /*
27: * Copyright (c) 1989, 1993
28: * The Regents of the University of California. All rights reserved.
29: *
30: * This code is derived from software contributed to Berkeley by
31: * Rick Macklem at The University of Guelph.
32: *
33: * Redistribution and use in source and binary forms, with or without
34: * modification, are permitted provided that the following conditions
35: * are met:
36: * 1. Redistributions of source code must retain the above copyright
37: * notice, this list of conditions and the following disclaimer.
38: * 2. Redistributions in binary form must reproduce the above copyright
39: * notice, this list of conditions and the following disclaimer in the
40: * documentation and/or other materials provided with the distribution.
41: * 3. All advertising materials mentioning features or use of this software
42: * must display the following acknowledgement:
43: * This product includes software developed by the University of
44: * California, Berkeley and its contributors.
45: * 4. Neither the name of the University nor the names of its contributors
46: * may be used to endorse or promote products derived from this software
47: * without specific prior written permission.
48: *
49: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
50: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
53: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59: * SUCH DAMAGE.
60: *
61: * @(#)nfs_bio.c 8.9 (Berkeley) 3/30/95
62: * FreeBSD-Id: nfs_bio.c,v 1.44 1997/09/10 19:52:25 phk Exp $
63: */
64:
65: #include <mach_nbc.h>
66: #include <sys/param.h>
67: #include <sys/systm.h>
68: #include <sys/resourcevar.h>
69: #include <sys/signalvar.h>
70: #include <sys/proc.h>
71: #include <sys/buf.h>
72: #include <sys/vnode.h>
73: #include <sys/mount.h>
74: #include <sys/kernel.h>
75: #include <sys/sysctl.h>
76:
77: #include <sys/vm.h>
78: #include <sys/vmparam.h>
79:
80: #include <nfs/rpcv2.h>
81: #include <nfs/nfsproto.h>
82: #include <nfs/nfs.h>
83: #include <nfs/nfsmount.h>
84: #include <nfs/nqnfs.h>
85: #include <nfs/nfsnode.h>
86:
87: #if MACH_NBC
88: #include <kern/mapfs.h>
89: #endif /* MACH_NBC */
90:
91: /* XXX CSM 11/25/97 Revisit when Ramesh merges vm with buffer cache
92: * Ifdef for FreeBSD-current merged buffer cache. It is unfortunate that these
93: * calls are not in getblk() and brelse() so that they would not be necessary
94: * here.
95: */
96: #ifndef B_VMIO
97: #define vfs_busy_pages(bp, f)
98: #define vfs_unbusy_pages(bp)
99: #endif
100:
101: static struct buf *nfs_getcacheblk __P((struct vnode *vp, daddr_t bn, int size,
102: struct proc *p));
103: static struct buf *nfs_getwriteblk __P((struct vnode *vp, daddr_t bn,
104: int size, struct proc *p,
105: struct ucred *cred, int off, int len));
106:
107: extern int nfs_numasync;
108: extern struct nfsstats nfsstats;
109:
110: /* XXX CSM 12/3/97 Revisit when Ramesh merges vm with buffer cache */
111: #ifdef B_VMIO
112: /*
113: * Vnode op for VM getpages.
114: */
115: int
116: nfs_getpages(ap)
117: struct vop_getpages_args *ap;
118: {
119: int i, bsize;
120: vm_object_t obj;
121: int pcount;
122: struct uio auio;
123: struct iovec aiov;
124: int error;
125: vm_page_t m;
126:
127: if (!(ap->a_vp->v_flag & VVMIO)) {
128: printf("nfs_getpages: called with non-VMIO vnode??\n");
129: return EOPNOTSUPP;
130: }
131:
132: pcount = round_page(ap->a_count) / PAGE_SIZE;
133:
134: obj = ap->a_m[ap->a_reqpage]->object;
135: bsize = ap->a_vp->v_mount->mnt_stat.f_iosize;
136:
137: for (i = 0; i < pcount; i++) {
138: if (i != ap->a_reqpage) {
139: vnode_pager_freepage(ap->a_m[i]);
140: }
141: }
142: m = ap->a_m[ap->a_reqpage];
143:
144: m->busy++;
145: m->flags &= ~PG_BUSY;
146:
147: auio.uio_iov = &aiov;
148: auio.uio_iovcnt = 1;
149: aiov.iov_base = 0;
150: aiov.iov_len = PAGE_SIZE;
151: auio.uio_resid = PAGE_SIZE;
152: auio.uio_offset = IDX_TO_OFF(m->pindex);
153: auio.uio_segflg = UIO_NOCOPY;
154: auio.uio_rw = UIO_READ;
155: auio.uio_procp = curproc;
156: error = nfs_bioread(ap->a_vp, &auio, IO_NODELOCKED, curproc->p_ucred, 1);
157:
158: m->flags |= PG_BUSY;
159: m->busy--;
160:
161: if (error && (auio.uio_resid == PAGE_SIZE))
162: return VM_PAGER_ERROR;
163: return 0;
164: }
165: #endif
166:
167: /*
168: * Vnode op for read using bio
169: * Any similarity to readip() is purely coincidental
170: */
171: int
172: nfs_bioread(vp, uio, ioflag, cred, getpages)
173: register struct vnode *vp;
174: register struct uio *uio;
175: int ioflag;
176: struct ucred *cred;
177: int getpages;
178: {
179: register struct nfsnode *np = VTONFS(vp);
180: register int biosize, diff, i;
181: struct buf *bp = 0, *rabp;
182: struct vattr vattr;
183: struct proc *p;
184: struct nfsmount *nmp = VFSTONFS(vp->v_mount);
185: daddr_t lbn, rabn;
186: int bufsize;
187: int nra, error = 0, n = 0, on = 0, not_readin;
188:
189: #if DIAGNOSTIC
190: if (uio->uio_rw != UIO_READ)
191: panic("nfs_read mode");
192: #endif
193: if (uio->uio_resid == 0)
194: return (0);
195: if (uio->uio_offset < 0)
196: return (EINVAL);
197: p = uio->uio_procp;
198: if ((nmp->nm_flag & (NFSMNT_NFSV3 | NFSMNT_GOTFSINFO)) == NFSMNT_NFSV3)
199: (void)nfs_fsinfo(nmp, vp, cred, p);
200: biosize = vp->v_mount->mnt_stat.f_iosize;
201: /*
202: * For nfs, cache consistency can only be maintained approximately.
203: * Although RFC1094 does not specify the criteria, the following is
204: * believed to be compatible with the reference port.
205: * For nqnfs, full cache consistency is maintained within the loop.
206: * For nfs:
207: * If the file's modify time on the server has changed since the
208: * last read rpc or you have written to the file,
209: * you may have lost data cache consistency with the
210: * server, so flush all of the file's data out of the cache.
211: * Then force a getattr rpc to ensure that you have up to date
212: * attributes.
213: * NB: This implies that cache data can be read when up to
214: * NFS_ATTRTIMEO seconds out of date. If you find that you need current
215: * attributes this could be forced by setting n_attrstamp to 0 before
216: * the VOP_GETATTR() call.
217: */
218: if ((nmp->nm_flag & NFSMNT_NQNFS) == 0) {
219: if (np->n_flag & NMODIFIED) {
220: if (vp->v_type != VREG) {
221: if (vp->v_type != VDIR)
222: panic("nfs: bioread, not dir");
223: nfs_invaldir(vp);
224: error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1);
225: if (error)
226: return (error);
227: }
228: np->n_attrstamp = 0;
229: error = VOP_GETATTR(vp, &vattr, cred, p);
230: if (error)
231: return (error);
232: np->n_mtime = vattr.va_mtime.tv_sec;
233: } else {
234: error = VOP_GETATTR(vp, &vattr, cred, p);
235: if (error)
236: return (error);
237: if (np->n_mtime != vattr.va_mtime.tv_sec) {
238: if (vp->v_type == VDIR)
239: nfs_invaldir(vp);
240: error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1);
241: if (error)
242: return (error);
243: np->n_mtime = vattr.va_mtime.tv_sec;
244: }
245: }
246: }
247: do {
248:
249: /*
250: * Get a valid lease. If cached data is stale, flush it.
251: */
252: if (nmp->nm_flag & NFSMNT_NQNFS) {
253: if (NQNFS_CKINVALID(vp, np, ND_READ)) {
254: do {
255: error = nqnfs_getlease(vp, ND_READ, cred, p);
256: } while (error == NQNFS_EXPIRED);
257: if (error)
258: return (error);
259: if (np->n_lrev != np->n_brev ||
260: (np->n_flag & NQNFSNONCACHE) ||
261: ((np->n_flag & NMODIFIED) && vp->v_type == VDIR)) {
262: if (vp->v_type == VDIR)
263: nfs_invaldir(vp);
264: error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1);
265: if (error)
266: return (error);
267: np->n_brev = np->n_lrev;
268: }
269: } else if (vp->v_type == VDIR && (np->n_flag & NMODIFIED)) {
270: nfs_invaldir(vp);
271: error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1);
272: if (error)
273: return (error);
274: }
275: }
276: if (np->n_flag & NQNFSNONCACHE) {
277: switch (vp->v_type) {
278: case VREG:
279: return (nfs_readrpc(vp, uio, cred));
280: case VLNK:
281: return (nfs_readlinkrpc(vp, uio, cred));
282: case VDIR:
283: break;
284: default:
285: printf(" NQNFSNONCACHE: type %x unexpected\n",
286: vp->v_type);
287: };
288: }
289: switch (vp->v_type) {
290: case VREG:
291: nfsstats.biocache_reads++;
292: lbn = uio->uio_offset / biosize;
293: on = uio->uio_offset & (biosize - 1);
294: not_readin = 1;
295:
296: /*
297: * Start the read ahead(s), as required.
298: */
299: if (nfs_numasync > 0 && nmp->nm_readahead > 0) {
300: for (nra = 0; nra < nmp->nm_readahead &&
301: (off_t)(lbn + 1 + nra) * biosize < np->n_size; nra++) {
302: rabn = lbn + 1 + nra;
303: if (!incore(vp, rabn)) {
304: rabp = nfs_getcacheblk(vp, rabn, biosize, p);
305: if (!rabp)
306: return (EINTR);
307: if ((rabp->b_flags & (B_CACHE|B_DELWRI)) == 0) {
308: rabp->b_flags |= (B_READ | B_ASYNC);
309: vfs_busy_pages(rabp, 0);
310: if (nfs_asyncio(rabp, cred)) {
311: rabp->b_flags |= B_INVAL|B_ERROR;
312: vfs_unbusy_pages(rabp);
313: brelse(rabp);
314: }
315: } else
316: brelse(rabp);
317: }
318: }
319: }
320:
321: /*
322: * If the block is in the cache and has the required data
323: * in a valid region, just copy it out.
324: * Otherwise, get the block and write back/read in,
325: * as required.
326: */
327: again:
328: bufsize = biosize;
329: if ((off_t)(lbn + 1) * biosize > np->n_size &&
330: (off_t)(lbn + 1) * biosize - np->n_size < biosize) {
331: bufsize = np->n_size - lbn * biosize;
332: bufsize = (bufsize + DEV_BSIZE - 1) & ~(DEV_BSIZE - 1);
333: }
334: bp = nfs_getcacheblk(vp, lbn, bufsize, p);
335: if (!bp)
336: return (EINTR);
337: /* XXX CSM 12/3/97 Revisit when Ramesh merges vm with buffer cache */
338: #ifdef B_VMIO
339: /*
340: * If we are being called from nfs_getpages, we must
341: * make sure the buffer is a vmio buffer. The vp will
342: * already be setup for vmio but there may be some old
343: * non-vmio buffers attached to it.
344: */
345: if (getpages && !(bp->b_flags & B_VMIO)) {
346: #if DIAGNOSTIC
347: printf("nfs_bioread: non vmio buf found, discarding\n");
348: #endif
349: bp->b_flags |= B_NOCACHE;
350: bp->b_flags |= B_INVAFTERWRITE;
351: if (bp->b_dirtyend > 0) {
352: if ((bp->b_flags & B_DELWRI) == 0)
353: panic("nfsbioread");
354: if (VOP_BWRITE(bp) == EINTR)
355: return (EINTR);
356: } else
357: brelse(bp);
358: goto again;
359: }
360: #endif /* B_VMIO */
361: if ((bp->b_flags & B_CACHE) == 0) {
362: bp->b_flags |= B_READ;
363: bp->b_flags &= ~(B_DONE | B_ERROR | B_INVAL);
364: not_readin = 0;
365: vfs_busy_pages(bp, 0);
366: error = nfs_doio(bp, cred, p);
367: if (error) {
368: brelse(bp);
369: return (error);
370: }
371: }
372: if (bufsize > on) {
373: n = min((unsigned)(bufsize - on), uio->uio_resid);
374: } else {
375: n = 0;
376: }
377: diff = np->n_size - uio->uio_offset;
378: if (diff < n)
379: n = diff;
380: if (not_readin && n > 0) {
381: if (on < bp->b_validoff || (on + n) > bp->b_validend) {
382: bp->b_flags |= B_NOCACHE;
383: bp->b_flags |= B_INVAFTERWRITE;
384: if (bp->b_dirtyend > 0) {
385: if ((bp->b_flags & B_DELWRI) == 0)
386: panic("nfsbioread");
387: if (VOP_BWRITE(bp) == EINTR)
388: return (EINTR);
389: } else
390: brelse(bp);
391: goto again;
392: }
393: }
394: vp->v_lastr = lbn;
395: diff = (on >= bp->b_validend) ? 0 : (bp->b_validend - on);
396: if (diff < n)
397: n = diff;
398: break;
399: case VLNK:
400: nfsstats.biocache_readlinks++;
401: bp = nfs_getcacheblk(vp, (daddr_t)0, NFS_MAXPATHLEN, p);
402: if (!bp)
403: return (EINTR);
404: if ((bp->b_flags & B_CACHE) == 0) {
405: bp->b_flags |= B_READ;
406: vfs_busy_pages(bp, 0);
407: error = nfs_doio(bp, cred, p);
408: if (error) {
409: bp->b_flags |= B_ERROR;
410: brelse(bp);
411: return (error);
412: }
413: }
414: n = min(uio->uio_resid, NFS_MAXPATHLEN - bp->b_resid);
415: on = 0;
416: break;
417: case VDIR:
418: nfsstats.biocache_readdirs++;
419: if (np->n_direofoffset
420: && uio->uio_offset >= np->n_direofoffset) {
421: return (0);
422: }
423: lbn = uio->uio_offset / NFS_DIRBLKSIZ;
424: on = uio->uio_offset & (NFS_DIRBLKSIZ - 1);
425: bp = nfs_getcacheblk(vp, lbn, NFS_DIRBLKSIZ, p);
426: if (!bp)
427: return (EINTR);
428: if ((bp->b_flags & B_CACHE) == 0) {
429: bp->b_flags |= B_READ;
430: vfs_busy_pages(bp, 0);
431: error = nfs_doio(bp, cred, p);
432: if (error) {
433: vfs_unbusy_pages(bp);
434: brelse(bp);
435: while (error == NFSERR_BAD_COOKIE) {
436: nfs_invaldir(vp);
437: error = nfs_vinvalbuf(vp, 0, cred, p, 1);
438: /*
439: * Yuck! The directory has been modified on the
440: * server. The only way to get the block is by
441: * reading from the beginning to get all the
442: * offset cookies.
443: */
444: for (i = 0; i <= lbn && !error; i++) {
445: if (np->n_direofoffset
446: && (i * NFS_DIRBLKSIZ) >= np->n_direofoffset)
447: return (0);
448: bp = nfs_getcacheblk(vp, i, NFS_DIRBLKSIZ, p);
449: if (!bp)
450: return (EINTR);
451: if ((bp->b_flags & B_DONE) == 0) {
452: bp->b_flags |= B_READ;
453: vfs_busy_pages(bp, 0);
454: error = nfs_doio(bp, cred, p);
455: if (error) {
456: vfs_unbusy_pages(bp);
457: brelse(bp);
458: } else if (i < lbn)
459: brelse(bp);
460: }
461: }
462: }
463: if (error)
464: return (error);
465: }
466: }
467:
468: /*
469: * If not eof and read aheads are enabled, start one.
470: * (You need the current block first, so that you have the
471: * directory offset cookie of the next block.)
472: */
473: if (nfs_numasync > 0 && nmp->nm_readahead > 0 &&
474: (np->n_direofoffset == 0 ||
475: (lbn + 1) * NFS_DIRBLKSIZ < np->n_direofoffset) &&
476: !(np->n_flag & NQNFSNONCACHE) &&
477: !incore(vp, lbn + 1)) {
478: rabp = nfs_getcacheblk(vp, lbn + 1, NFS_DIRBLKSIZ, p);
479: if (rabp) {
480: if ((rabp->b_flags & (B_CACHE|B_DELWRI)) == 0) {
481: rabp->b_flags |= (B_READ | B_ASYNC);
482: vfs_busy_pages(rabp, 0);
483: if (nfs_asyncio(rabp, cred)) {
484: rabp->b_flags |= B_INVAL|B_ERROR;
485: vfs_unbusy_pages(rabp);
486: brelse(rabp);
487: }
488: } else {
489: brelse(rabp);
490: }
491: }
492: }
493: /*
494: * Make sure we use a signed variant of min() since
495: * the second term may be negative.
496: */
497: n = lmin(uio->uio_resid, NFS_DIRBLKSIZ - bp->b_resid - on);
498: break;
499: default:
500: printf(" nfs_bioread: type %x unexpected\n",vp->v_type);
501: break;
502: };
503:
504: if (n > 0) {
505: error = uiomove(bp->b_data + on, (int)n, uio);
506: }
507: switch (vp->v_type) {
508: case VREG:
509: break;
510: case VLNK:
511: n = 0;
512: break;
513: case VDIR:
514: if (np->n_flag & NQNFSNONCACHE)
515: bp->b_flags |= B_INVAL;
516: break;
517: default:
518: printf(" nfs_bioread: type %x unexpected\n",vp->v_type);
519: }
520: brelse(bp);
521: } while (error == 0 && uio->uio_resid > 0 && n > 0);
522: return (error);
523: }
524:
525: /*
526: * Vnode op for write using bio
527: */
528: int
529: nfs_write(ap)
530: struct vop_write_args /* {
531: struct vnode *a_vp;
532: struct uio *a_uio;
533: int a_ioflag;
534: struct ucred *a_cred;
535: } */ *ap;
536: {
537: register int biosize;
538: register struct uio *uio = ap->a_uio;
539: struct proc *p = uio->uio_procp;
540: register struct vnode *vp = ap->a_vp;
541: struct nfsnode *np = VTONFS(vp);
542: register struct ucred *cred = ap->a_cred;
543: int ioflag = ap->a_ioflag;
544: struct buf *bp;
545: struct vattr vattr;
546: struct nfsmount *nmp = VFSTONFS(vp->v_mount);
547: daddr_t lbn;
548: int bufsize;
549: int n, on, error = 0, iomode, must_commit;
550:
551: #if DIAGNOSTIC
552: if (uio->uio_rw != UIO_WRITE)
553: panic("nfs_write mode");
554: if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != current_proc())
555: panic("nfs_write proc");
556: #endif
557: if (vp->v_type != VREG)
558: return (EIO);
559: if (np->n_flag & NWRITEERR) {
560: np->n_flag &= ~NWRITEERR;
561: return (np->n_error);
562: }
563: if ((nmp->nm_flag & (NFSMNT_NFSV3 | NFSMNT_GOTFSINFO)) == NFSMNT_NFSV3)
564: (void)nfs_fsinfo(nmp, vp, cred, p);
565: if (ioflag & (IO_APPEND | IO_SYNC)) {
566: if (np->n_flag & NMODIFIED) {
567: np->n_attrstamp = 0;
568: error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1);
569: if (error)
570: return (error);
571: }
572: if (ioflag & IO_APPEND) {
573: np->n_attrstamp = 0;
574: error = VOP_GETATTR(vp, &vattr, cred, p);
575: if (error)
576: return (error);
577: uio->uio_offset = np->n_size;
578: }
579: }
580: if (uio->uio_offset < 0)
581: return (EINVAL);
582: if (uio->uio_resid == 0)
583: return (0);
584: /*
585: * Maybe this should be above the vnode op call, but so long as
586: * file servers have no limits, i don't think it matters
587: */
588: if (p && uio->uio_offset + uio->uio_resid >
589: p->p_rlimit[RLIMIT_FSIZE].rlim_cur) {
590: psignal(p, SIGXFSZ);
591: return (EFBIG);
592: }
593: /*
594: * I use nm_rsize, not nm_wsize so that all buffer cache blocks
595: * will be the same size within a filesystem. nfs_writerpc will
596: * still use nm_wsize when sizing the rpc's.
597: */
598: biosize = vp->v_mount->mnt_stat.f_iosize;
599: do {
600: /*
601: * Check for a valid write lease.
602: */
603: if ((nmp->nm_flag & NFSMNT_NQNFS) &&
604: NQNFS_CKINVALID(vp, np, ND_WRITE)) {
605: do {
606: error = nqnfs_getlease(vp, ND_WRITE, cred, p);
607: } while (error == NQNFS_EXPIRED);
608: if (error)
609: return (error);
610: if (np->n_lrev != np->n_brev ||
611: (np->n_flag & NQNFSNONCACHE)) {
612: error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1);
613: if (error)
614: return (error);
615: np->n_brev = np->n_lrev;
616: }
617: }
618: if ((np->n_flag & NQNFSNONCACHE) && uio->uio_iovcnt == 1) {
619: iomode = NFSV3WRITE_FILESYNC;
620: error = nfs_writerpc(vp, uio, cred, &iomode, &must_commit);
621: if (must_commit)
622: nfs_clearcommit(vp->v_mount);
623: return (error);
624: }
625: nfsstats.biocache_writes++;
626: lbn = uio->uio_offset / biosize;
627: on = uio->uio_offset & (biosize-1);
628: n = min((unsigned)(biosize - on), uio->uio_resid);
629: again:
630: if (uio->uio_offset + n > np->n_size) {
631: np->n_size = uio->uio_offset + n;
632: np->n_flag |= NMODIFIED;
633: #if MACH_NBC
634: if ((vp->v_type == VREG) && (vp->v_vm_info && !(vp->v_vm_info->mapped))) {
635: #endif /* MACH_NBC */
636: vnode_pager_setsize(vp, (u_long)np->n_size);
637: #if MACH_NBC
638: }
639: #endif /* MACH_NBC */
640:
641: }
642: bufsize = biosize;
643: if ((lbn + 1) * biosize > np->n_size) {
644: bufsize = np->n_size - lbn * biosize;
645: bufsize = (bufsize + DEV_BSIZE - 1) & ~(DEV_BSIZE - 1);
646: }
647: bp = nfs_getwriteblk(vp, lbn, bufsize, p, cred, on, n);
648: if (!bp)
649: return (EINTR);
650: if (bp->b_wcred == NOCRED) {
651: crhold(cred);
652: bp->b_wcred = cred;
653: }
654: np->n_flag |= NMODIFIED;
655:
656: /*
657: * Check for valid write lease and get one as required.
658: * In case getblk() and/or bwrite() delayed us.
659: */
660: if ((nmp->nm_flag & NFSMNT_NQNFS) &&
661: NQNFS_CKINVALID(vp, np, ND_WRITE)) {
662: do {
663: error = nqnfs_getlease(vp, ND_WRITE, cred, p);
664: } while (error == NQNFS_EXPIRED);
665: if (error) {
666: brelse(bp);
667: return (error);
668: }
669: if (np->n_lrev != np->n_brev ||
670: (np->n_flag & NQNFSNONCACHE)) {
671: brelse(bp);
672: error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1);
673: if (error)
674: return (error);
675: np->n_brev = np->n_lrev;
676: goto again;
677: }
678: }
679: error = uiomove((char *)bp->b_data + on, n, uio);
680: if (error) {
681: bp->b_flags |= B_ERROR;
682: brelse(bp);
683: return (error);
684: }
685: if (bp->b_dirtyend > 0) {
686: bp->b_dirtyoff = min(on, bp->b_dirtyoff);
687: bp->b_dirtyend = max((on + n), bp->b_dirtyend);
688: } else {
689: bp->b_dirtyoff = on;
690: bp->b_dirtyend = on + n;
691: }
692: if (bp->b_validend == 0 || bp->b_validend < bp->b_dirtyoff ||
693: bp->b_validoff > bp->b_dirtyend) {
694: bp->b_validoff = bp->b_dirtyoff;
695: bp->b_validend = bp->b_dirtyend;
696: } else {
697: bp->b_validoff = min(bp->b_validoff, bp->b_dirtyoff);
698: bp->b_validend = max(bp->b_validend, bp->b_dirtyend);
699: }
700:
701: /*
702: * Since this block is being modified, it must be written
703: * again and not just committed.
704: */
705: bp->b_flags &= ~B_NEEDCOMMIT;
706:
707: /*
708: * If the lease is non-cachable or IO_SYNC do bwrite().
709: */
710: if ((np->n_flag & NQNFSNONCACHE) || (ioflag & IO_SYNC)) {
711: bp->b_proc = p;
712: error = VOP_BWRITE(bp);
713: if (error)
714: return (error);
715: if (np->n_flag & NQNFSNONCACHE) {
716: error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1);
717: if (error)
718: return (error);
719: }
720: } else if ((n + on) == biosize &&
721: (nmp->nm_flag & NFSMNT_NQNFS) == 0) {
722: bp->b_proc = (struct proc *)0;
723: bp->b_flags |= B_ASYNC;
724: (void)nfs_writebp(bp, 0);
725: } else
726: bdwrite(bp);
727: } while (uio->uio_resid > 0 && n > 0);
728: return (0);
729: }
730:
731: /*
732: * Get a cache block for writing. The range to be written is
733: * (off..off+len) within the block. This routine ensures that the
734: * block is either has no dirty region or that the given range is
735: * contiguous with the existing dirty region.
736: */
737: static struct buf *
738: nfs_getwriteblk(vp, bn, size, p, cred, off, len)
739: struct vnode *vp;
740: daddr_t bn;
741: int size;
742: struct proc *p;
743: struct ucred *cred;
744: int off, len;
745: {
746: struct nfsnode *np = VTONFS(vp);
747: struct buf *bp;
748: int error;
749:
750: again:
751: bp = nfs_getcacheblk(vp, bn, size, p);
752: if (!bp)
753: return (NULL);
754: if (bp->b_wcred == NOCRED) {
755: crhold(cred);
756: bp->b_wcred = cred;
757: }
758:
759: if ((bp->b_blkno * DEV_BSIZE) + bp->b_dirtyend > np->n_size) {
760: bp->b_dirtyend = np->n_size - (bp->b_blkno * DEV_BSIZE);
761: }
762:
763: /*
764: * If the new write will leave a contiguous dirty
765: * area, just update the b_dirtyoff and b_dirtyend,
766: * otherwise try to extend the dirty region.
767: */
768: if (bp->b_dirtyend > 0 &&
769: (off > bp->b_dirtyend || (off + len) < bp->b_dirtyoff)) {
770: struct iovec iov;
771: struct uio uio;
772: off_t boff, start, end;
773:
774: boff = ((off_t)bp->b_blkno) * DEV_BSIZE;
775: if (off > bp->b_dirtyend) {
776: start = boff + bp->b_validend;
777: end = boff + off;
778: } else {
779: start = boff + off + len;
780: end = boff + bp->b_validoff;
781: }
782:
783: /*
784: * It may be that the valid region in the buffer
785: * covers the region we want, in which case just
786: * extend the dirty region. Otherwise we try to
787: * extend the valid region.
788: */
789: if (end > start) {
790: uio.uio_iov = &iov;
791: uio.uio_iovcnt = 1;
792: uio.uio_offset = start;
793: uio.uio_resid = end - start;
794: uio.uio_segflg = UIO_SYSSPACE;
795: uio.uio_rw = UIO_READ;
796: uio.uio_procp = p;
797: iov.iov_base = bp->b_data + (start - boff);
798: iov.iov_len = end - start;
799: error = nfs_readrpc(vp, &uio, cred);
800: if (error) {
801: /*
802: * If we couldn't read, fall back to writing
803: * out the old dirty region.
804: */
805: bp->b_proc = p;
806: if (VOP_BWRITE(bp) == EINTR)
807: return (NULL);
808: goto again;
809: } else {
810: /*
811: * The read worked.
812: */
813: if (uio.uio_resid > 0) {
814: /*
815: * If there was a short read,
816: * just zero fill.
817: */
818: bzero(iov.iov_base,
819: uio.uio_resid);
820: }
821: if (off > bp->b_dirtyend)
822: bp->b_validend = off;
823: else
824: bp->b_validoff = off + len;
825: }
826: }
827:
828: /*
829: * We now have a valid region which extends up to the
830: * dirty region which we want.
831: */
832: if (off > bp->b_dirtyend)
833: bp->b_dirtyend = off;
834: else
835: bp->b_dirtyoff = off + len;
836: }
837:
838: return bp;
839: }
840:
841: /*
842: * Get an nfs cache block.
843: * Allocate a new one if the block isn't currently in the cache
844: * and return the block marked busy. If the calling process is
845: * interrupted by a signal for an interruptible mount point, return
846: * NULL.
847: */
848: static struct buf *
849: nfs_getcacheblk(vp, bn, size, p)
850: struct vnode *vp;
851: daddr_t bn;
852: int size;
853: struct proc *p;
854: {
855: register struct buf *bp;
856: struct nfsmount *nmp = VFSTONFS(vp->v_mount);
857: int biosize = vp->v_mount->mnt_stat.f_iosize;
858:
859: if (nmp->nm_flag & NFSMNT_INT) {
860: bp = getblk(vp, bn, size, PCATCH, 0);
861: while (bp == (struct buf *)0) {
862: if (nfs_sigintr(nmp, (struct nfsreq *)0, p))
863: return ((struct buf *)0);
864: bp = getblk(vp, bn, size, 0, 2 * hz);
865: }
866: } else
867: bp = getblk(vp, bn, size, 0, 0);
868:
869: if( vp->v_type == VREG)
870: bp->b_blkno = (bn * biosize) / DEV_BSIZE;
871:
872: return (bp);
873: }
874:
875: /*
876: * Flush and invalidate all dirty buffers. If another process is already
877: * doing the flush, just wait for completion.
878: */
879: int
880: nfs_vinvalbuf(vp, flags, cred, p, intrflg)
881: struct vnode *vp;
882: int flags;
883: struct ucred *cred;
884: struct proc *p;
885: int intrflg;
886: {
887: register struct nfsnode *np = VTONFS(vp);
888: struct nfsmount *nmp = VFSTONFS(vp->v_mount);
889: int error = 0, slpflag, slptimeo;
890:
891: if ((nmp->nm_flag & NFSMNT_INT) == 0)
892: intrflg = 0;
893: if (intrflg) {
894: slpflag = PCATCH;
895: slptimeo = 2 * hz;
896: } else {
897: slpflag = 0;
898: slptimeo = 0;
899: }
900: /*
901: * First wait for any other process doing a flush to complete.
902: */
903: while (np->n_flag & NFLUSHINPROG) {
904: np->n_flag |= NFLUSHWANT;
905: error = tsleep((caddr_t)&np->n_flag, PRIBIO + 2, "nfsvinval",
906: slptimeo);
907: if (error && intrflg && nfs_sigintr(nmp, (struct nfsreq *)0, p))
908: return (EINTR);
909: }
910:
911: /*
912: * Now, flush as required.
913: */
914: np->n_flag |= NFLUSHINPROG;
915: error = vinvalbuf(vp, flags, cred, p, slpflag, 0);
916: while (error) {
917: if (intrflg && nfs_sigintr(nmp, (struct nfsreq *)0, p)) {
918: np->n_flag &= ~NFLUSHINPROG;
919: if (np->n_flag & NFLUSHWANT) {
920: np->n_flag &= ~NFLUSHWANT;
921: wakeup((caddr_t)&np->n_flag);
922: }
923: return (EINTR);
924: }
925: error = vinvalbuf(vp, flags, cred, p, 0, slptimeo);
926: }
927: np->n_flag &= ~(NMODIFIED | NFLUSHINPROG);
928: if (np->n_flag & NFLUSHWANT) {
929: np->n_flag &= ~NFLUSHWANT;
930: wakeup((caddr_t)&np->n_flag);
931: }
932: return (0);
933: }
934:
935: /*
936: * Initiate asynchronous I/O. Return an error if no nfsiods are available.
937: * This is mainly to avoid queueing async I/O requests when the nfsiods
938: * are all hung on a dead server.
939: */
940: int
941: nfs_asyncio(bp, cred)
942: register struct buf *bp;
943: struct ucred *cred;
944: {
945: struct nfsmount *nmp;
946: int i;
947: int gotiod;
948: int slpflag = 0;
949: int slptimeo = 0;
950: int error;
951:
952: if (nfs_numasync == 0)
953: return (EIO);
954:
955: nmp = VFSTONFS(bp->b_vp->v_mount);
956: again:
957: if (nmp->nm_flag & NFSMNT_INT)
958: slpflag = PCATCH;
959: gotiod = FALSE;
960:
961: /*
962: * Find a free iod to process this request.
963: */
964: for (i = 0; i < NFS_MAXASYNCDAEMON; i++)
965: if (nfs_iodwant[i]) {
966: /*
967: * Found one, so wake it up and tell it which
968: * mount to process.
969: */
970: NFS_DPF(ASYNCIO,
971: ("nfs_asyncio: waking iod %d for mount %p\n",
972: i, nmp));
973: nfs_iodwant[i] = (struct proc *)0;
974: nfs_iodmount[i] = nmp;
975: nmp->nm_bufqiods++;
976: wakeup((caddr_t)&nfs_iodwant[i]);
977: gotiod = TRUE;
978: break;
979: }
980:
981: /*
982: * If none are free, we may already have an iod working on this mount
983: * point. If so, it will process our request.
984: */
985: if (!gotiod) {
986: if (nmp->nm_bufqiods > 0) {
987: NFS_DPF(ASYNCIO,
988: ("nfs_asyncio: %d iods are already processing mount %p\n",
989: nmp->nm_bufqiods, nmp));
990: gotiod = TRUE;
991: }
992: }
993:
994: /*
995: * If we have an iod which can process the request, then queue
996: * the buffer.
997: */
998: if (gotiod) {
999: /*
1000: * Ensure that the queue never grows too large.
1001: */
1002: while (nmp->nm_bufqlen >= 2*nfs_numasync) {
1003: NFS_DPF(ASYNCIO,
1004: ("nfs_asyncio: waiting for mount %p queue to drain\n", nmp));
1005: nmp->nm_bufqwant = TRUE;
1006: error = tsleep(&nmp->nm_bufq, slpflag | PRIBIO,
1007: "nfsaio", slptimeo);
1008: if (error) {
1009: if (nfs_sigintr(nmp, NULL, bp->b_proc))
1010: return (EINTR);
1011: if (slpflag == PCATCH) {
1012: slpflag = 0;
1013: slptimeo = 2 * hz;
1014: }
1015: }
1016: /*
1017: * We might have lost our iod while sleeping,
1018: * so check and loop if nescessary.
1019: */
1020: if (nmp->nm_bufqiods == 0) {
1021: NFS_DPF(ASYNCIO,
1022: ("nfs_asyncio: no iods after mount %p queue was drained, looping\n", nmp));
1023: goto again;
1024: }
1025: }
1026:
1027: if (bp->b_flags & B_READ) {
1028: if (bp->b_rcred == NOCRED && cred != NOCRED) {
1029: crhold(cred);
1030: bp->b_rcred = cred;
1031: }
1032: } else {
1033: bp->b_flags |= B_WRITEINPROG;
1034: if (bp->b_wcred == NOCRED && cred != NOCRED) {
1035: crhold(cred);
1036: bp->b_wcred = cred;
1037: }
1038: }
1039:
1040: TAILQ_INSERT_TAIL(&nmp->nm_bufq, bp, b_freelist);
1041: nmp->nm_bufqlen++;
1042: return (0);
1043: }
1044:
1045: /*
1046: * All the iods are busy on other mounts, so return EIO to
1047: * force the caller to process the i/o synchronously.
1048: */
1049: NFS_DPF(ASYNCIO, ("nfs_asyncio: no iods available, i/o is synchronous\n"));
1050: return (EIO);
1051: }
1052:
1053: /*
1054: * Do an I/O operation to/from a cache block. This may be called
1055: * synchronously or from an nfsiod.
1056: */
1057: int
1058: nfs_doio(bp, cr, p)
1059: register struct buf *bp;
1060: struct ucred *cr;
1061: struct proc *p;
1062: {
1063: register struct uio *uiop;
1064: register struct vnode *vp;
1065: struct nfsnode *np;
1066: struct nfsmount *nmp;
1067: int error = 0, diff, len, iomode, must_commit = 0;
1068: struct uio uio;
1069: struct iovec io;
1070:
1071: vp = bp->b_vp;
1072: NFSTRACE(NFSTRC_DIO, vp);
1073: np = VTONFS(vp);
1074: nmp = VFSTONFS(vp->v_mount);
1075: uiop = &uio;
1076: uiop->uio_iov = &io;
1077: uiop->uio_iovcnt = 1;
1078: uiop->uio_segflg = UIO_SYSSPACE;
1079: uiop->uio_procp = p;
1080:
1081: /*
1082: * Historically, paging was done with physio, but no more.
1083: */
1084: if (bp->b_flags & B_PHYS) {
1085: /*
1086: * ...though reading /dev/drum still gets us here.
1087: */
1088: io.iov_len = uiop->uio_resid = bp->b_bcount;
1089: /* mapping was done by vmapbuf() */
1090: io.iov_base = bp->b_data;
1091: uiop->uio_offset = ((off_t)bp->b_blkno) * DEV_BSIZE;
1092: if (bp->b_flags & B_READ) {
1093: uiop->uio_rw = UIO_READ;
1094: nfsstats.read_physios++;
1095: error = nfs_readrpc(vp, uiop, cr);
1096: } else {
1097: int com;
1098:
1099: iomode = NFSV3WRITE_DATASYNC;
1100: uiop->uio_rw = UIO_WRITE;
1101: nfsstats.write_physios++;
1102: error = nfs_writerpc(vp, uiop, cr, &iomode, &com);
1103: }
1104: if (error) {
1105: bp->b_flags |= B_ERROR;
1106: bp->b_error = error;
1107: }
1108: } else if (bp->b_flags & B_READ) {
1109: io.iov_len = uiop->uio_resid = bp->b_bcount;
1110: io.iov_base = bp->b_data;
1111: uiop->uio_rw = UIO_READ;
1112: switch (vp->v_type) {
1113: case VREG:
1114: uiop->uio_offset = ((off_t)bp->b_blkno) * DEV_BSIZE;
1115: nfsstats.read_bios++;
1116: error = nfs_readrpc(vp, uiop, cr);
1117: if (!error) {
1118: bp->b_validoff = 0;
1119: if (uiop->uio_resid) {
1120: /*
1121: * If len > 0, there is a hole in the file and
1122: * no writes after the hole have been pushed to
1123: * the server yet.
1124: * Just zero fill the rest of the valid area.
1125: */
1126: diff = bp->b_bcount - uiop->uio_resid;
1127: len = np->n_size - (((u_quad_t)bp->b_blkno) * DEV_BSIZE
1128: + diff);
1129: if (len > 0) {
1130: len = min(len, uiop->uio_resid);
1131: bzero((char *)bp->b_data + diff, len);
1132: bp->b_validend = diff + len;
1133: } else
1134: bp->b_validend = diff;
1135: } else
1136: bp->b_validend = bp->b_bcount;
1137: }
1138: if (p && (vp->v_flag & VTEXT) &&
1139: (((nmp->nm_flag & NFSMNT_NQNFS) &&
1140: NQNFS_CKINVALID(vp, np, ND_READ) &&
1141: np->n_lrev != np->n_brev) ||
1142: (!(nmp->nm_flag & NFSMNT_NQNFS) &&
1143: np->n_mtime != np->n_vattr.va_mtime.tv_sec))) {
1144: uprintf("Process killed due to text file modification\n");
1145: psignal(p, SIGKILL);
1146: p->p_flag |= P_NOSWAP;
1147: }
1148: break;
1149: case VLNK:
1150: uiop->uio_offset = (off_t)0;
1151: nfsstats.readlink_bios++;
1152: error = nfs_readlinkrpc(vp, uiop, cr);
1153: break;
1154: case VDIR:
1155: nfsstats.readdir_bios++;
1156: uiop->uio_offset = ((u_quad_t)bp->b_lblkno) * NFS_DIRBLKSIZ;
1157: if (!(nmp->nm_flag & NFSMNT_NFSV3))
1158: nmp->nm_flag &= ~NFSMNT_RDIRPLUS; /* [email protected] */
1159: if (nmp->nm_flag & NFSMNT_RDIRPLUS) {
1160: error = nfs_readdirplusrpc(vp, uiop, cr);
1161: if (error == NFSERR_NOTSUPP)
1162: nmp->nm_flag &= ~NFSMNT_RDIRPLUS;
1163: }
1164: if ((nmp->nm_flag & NFSMNT_RDIRPLUS) == 0)
1165: error = nfs_readdirrpc(vp, uiop, cr);
1166: break;
1167: default:
1168: printf("nfs_doio: type %x unexpected\n",vp->v_type);
1169: break;
1170: };
1171: if (error) {
1172: bp->b_flags |= B_ERROR;
1173: bp->b_error = error;
1174: }
1175: } else {
1176: if (((bp->b_blkno * DEV_BSIZE) + bp->b_dirtyend) > np->n_size)
1177: bp->b_dirtyend = np->n_size - (bp->b_blkno * DEV_BSIZE);
1178:
1179: if (bp->b_dirtyend > bp->b_dirtyoff) {
1180: io.iov_len = uiop->uio_resid = bp->b_dirtyend
1181: - bp->b_dirtyoff;
1182: uiop->uio_offset = ((off_t)bp->b_blkno) * DEV_BSIZE
1183: + bp->b_dirtyoff;
1184: io.iov_base = (char *)bp->b_data + bp->b_dirtyoff;
1185: uiop->uio_rw = UIO_WRITE;
1186: nfsstats.write_bios++;
1187: /* XXX CSM 12/3/97 Revisit when buffer cache upgraded */
1188: #ifdef notyet
1189: if ((bp->b_flags & (B_ASYNC | B_NEEDCOMMIT | B_NOCACHE | B_CLUSTER)) == B_ASYNC)
1190: #else
1191: if ((bp->b_flags & (B_ASYNC | B_NEEDCOMMIT | B_NOCACHE)) == B_ASYNC)
1192: #endif
1193: iomode = NFSV3WRITE_UNSTABLE;
1194: else
1195: iomode = NFSV3WRITE_FILESYNC;
1196: bp->b_flags |= B_WRITEINPROG;
1197: error = nfs_writerpc(vp, uiop, cr, &iomode, &must_commit);
1198: if (!error && iomode == NFSV3WRITE_UNSTABLE) {
1199: bp->b_flags |= B_NEEDCOMMIT;
1200: /* XXX CSM 12/3/97 Revisit when buffer cache upgraded */
1201: #ifdef notyet
1202: if (bp->b_dirtyoff == 0
1203: && bp->b_dirtyend == bp->b_bufsize)
1204: bp->b_flags |= B_CLUSTEROK;
1205: #endif
1206: } else
1207: bp->b_flags &= ~B_NEEDCOMMIT;
1208: bp->b_flags &= ~B_WRITEINPROG;
1209:
1210: /*
1211: * For an interrupted write, the buffer is still valid
1212: * and the write hasn't been pushed to the server yet,
1213: * so we can't set B_ERROR and report the interruption
1214: * by setting B_EINTR. For the B_ASYNC case, B_EINTR
1215: * is not relevant, so the rpc attempt is essentially
1216: * a noop. For the case of a V3 write rpc not being
1217: * committed to stable storage, the block is still
1218: * dirty and requires either a commit rpc or another
1219: * write rpc with iomode == NFSV3WRITE_FILESYNC before
1220: * the block is reused. This is indicated by setting
1221: * the B_DELWRI and B_NEEDCOMMIT flags.
1222: */
1223: if (error == EINTR
1224: || (!error && (bp->b_flags & B_NEEDCOMMIT))) {
1225: int s;
1226:
1227: bp->b_flags &= ~(B_INVAL|B_NOCACHE);
1228: /* XXX CSM 12/3/97 Revisit when buffer cache upgraded */
1229: #ifdef notyet
1230: ++numdirtybuffers;
1231: #endif
1232: bp->b_flags |= B_DELWRI;
1233:
1234: /*
1235: * Since for the B_ASYNC case, nfs_bwrite() has reassigned the
1236: * buffer to the clean list, we have to reassign it back to the
1237: * dirty one. Ugh.
1238: */
1239: if (bp->b_flags & B_ASYNC) {
1240: s = splbio();
1241: reassignbuf(bp, vp);
1242: splx(s);
1243: } else
1244: bp->b_flags |= B_EINTR;
1245: } else {
1246: if (error) {
1247: bp->b_flags |= B_ERROR;
1248: bp->b_error = np->n_error = error;
1249: np->n_flag |= NWRITEERR;
1250: }
1251: bp->b_dirtyoff = bp->b_dirtyend = 0;
1252: }
1253: } else {
1254: bp->b_resid = 0;
1255: biodone(bp);
1256: NFSTRACE(NFSTRC_DIO_DONE, vp);
1257: return (0);
1258: }
1259: }
1260: bp->b_resid = uiop->uio_resid;
1261: if (must_commit)
1262: nfs_clearcommit(vp->v_mount);
1263: biodone(bp);
1264: NFSTRACE(NFSTRC_DIO_DONE, vp);
1265: return (error);
1266: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.