![[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 [CSRG BSD Unix] / 43BSDReno / sys / nfs|
Return to nfs_bio.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / nfs |
1.1 root 1: /*
2: * Copyright (c) 1989 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Rick Macklem at The University of Guelph.
7: *
8: * Redistribution is only permitted until one year after the first shipment
9: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
10: * binary forms are permitted provided that: (1) source distributions retain
11: * this entire copyright notice and comment, and (2) distributions including
12: * binaries display the following acknowledgement: This product includes
13: * software developed by the University of California, Berkeley and its
14: * contributors'' in the documentation or other materials provided with the
15: * distribution and in all advertising materials mentioning features or use
16: * of this software. Neither the name of the University nor the names of
17: * its contributors may be used to endorse or promote products derived from
18: * this software without specific prior written permission.
19: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
20: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
21: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
22: *
23: * @(#)nfs_bio.c 7.16 (Berkeley) 6/28/90
24: */
25:
26: #include "param.h"
27: #include "user.h"
28: #include "buf.h"
29: #include "vnode.h"
30: #include "trace.h"
31: #include "mount.h"
32: #include "nfsnode.h"
33: #include "nfsv2.h"
34: #include "nfs.h"
35: #include "nfsiom.h"
36: #include "nfsmount.h"
37:
38: /* True and false, how exciting */
39: #define TRUE 1
40: #define FALSE 0
41:
42: /*
43: * Vnode op for read using bio
44: * Any similarity to readip() is purely coincidental
45: */
46: nfs_bioread(vp, uio, ioflag, cred)
47: register struct vnode *vp;
48: register struct uio *uio;
49: int ioflag;
50: struct ucred *cred;
51: {
52: register struct nfsnode *np = VTONFS(vp);
53: register int biosize;
54: struct buf *bp;
55: struct vattr vattr;
56: daddr_t lbn, bn, rablock;
57: int diff, error = 0;
58: long n, on;
59:
60: #ifdef lint
61: ioflag = ioflag;
62: #endif /* lint */
63: if (uio->uio_rw != UIO_READ)
64: panic("nfs_read mode");
65: if (uio->uio_resid == 0)
66: return (0);
67: if (uio->uio_offset < 0 && vp->v_type != VDIR)
68: return (EINVAL);
69: biosize = VFSTONFS(vp->v_mount)->nm_rsize;
70: /*
71: * If the file's modify time on the server has changed since the
72: * last read rpc or you have written to the file,
73: * you may have lost data cache consistency with the
74: * server, so flush all of the file's data out of the cache.
75: * Then force a getattr rpc to ensure that you have up to date
76: * attributes.
77: * NB: This implies that cache data can be read when up to
78: * NFS_ATTRTIMEO seconds out of date. If you find that you need current
79: * attributes this could be forced by setting n_attrstamp to 0 before
80: * the nfs_dogetattr() call.
81: */
82: if (vp->v_type != VLNK) {
83: if (np->n_flag & NMODIFIED) {
84: np->n_flag &= ~NMODIFIED;
85: vinvalbuf(vp, TRUE);
86: np->n_attrstamp = 0;
87: np->n_direofoffset = 0;
88: if (error = nfs_dogetattr(vp, &vattr, cred, 1))
89: return (error);
90: np->n_mtime = vattr.va_mtime.tv_sec;
91: } else {
92: if (error = nfs_dogetattr(vp, &vattr, cred, 1))
93: return (error);
94: if (np->n_mtime != vattr.va_mtime.tv_sec) {
95: np->n_direofoffset = 0;
96: vinvalbuf(vp, TRUE);
97: np->n_mtime = vattr.va_mtime.tv_sec;
98: }
99: }
100: }
101: do {
102: switch (vp->v_type) {
103: case VREG:
104: nfsstats.biocache_reads++;
105: lbn = uio->uio_offset / biosize;
106: on = uio->uio_offset & (biosize-1);
107: n = MIN((unsigned)(biosize - on), uio->uio_resid);
108: diff = np->n_size - uio->uio_offset;
109: if (diff <= 0)
110: return (error);
111: if (diff < n)
112: n = diff;
113: bn = lbn*(biosize/DEV_BSIZE);
114: rablock = (lbn+1)*(biosize/DEV_BSIZE);
115: if (vp->v_lastr + 1 == lbn &&
116: np->n_size > (rablock * DEV_BSIZE))
117: error = breada(vp, bn, biosize, rablock, biosize,
118: cred, &bp);
119: else
120: error = bread(vp, bn, biosize, cred, &bp);
121: vp->v_lastr = lbn;
122: if (bp->b_resid) {
123: diff = (on >= (biosize-bp->b_resid)) ? 0 :
124: (biosize-bp->b_resid-on);
125: n = MIN(n, diff);
126: }
127: break;
128: case VLNK:
129: nfsstats.biocache_readlinks++;
130: on = 0;
131: error = bread(vp, (daddr_t)0, NFS_MAXPATHLEN, cred, &bp);
132: n = MIN(uio->uio_resid, NFS_MAXPATHLEN - bp->b_resid);
133: break;
134: case VDIR:
135: nfsstats.biocache_readdirs++;
136: on = 0;
137: error = bread(vp, uio->uio_offset, DIRBLKSIZ, cred, &bp);
138: n = MIN(uio->uio_resid, DIRBLKSIZ - bp->b_resid);
139: break;
140: };
141: if (error) {
142: brelse(bp);
143: return (error);
144: }
145: if (n > 0)
146: error = uiomove(bp->b_un.b_addr + on, (int)n, uio);
147: switch (vp->v_type) {
148: case VREG:
149: if (n+on == biosize || uio->uio_offset == np->n_size)
150: bp->b_flags |= B_AGE;
151: break;
152: case VLNK:
153: n = 0;
154: break;
155: case VDIR:
156: uio->uio_offset = bp->b_blkno;
157: break;
158: };
159: brelse(bp);
160: } while (error == 0 && uio->uio_resid > 0 && n != 0);
161: return (error);
162: }
163:
164: /*
165: * Vnode op for write using bio
166: */
167: nfs_write(vp, uio, ioflag, cred)
168: register struct vnode *vp;
169: register struct uio *uio;
170: int ioflag;
171: struct ucred *cred;
172: {
173: register int biosize;
174: struct buf *bp;
175: struct nfsnode *np = VTONFS(vp);
176: struct vattr vattr;
177: daddr_t lbn, bn;
178: int n, on, error = 0;
179:
180: if (uio->uio_rw != UIO_WRITE)
181: panic("nfs_write mode");
182: if (vp->v_type != VREG)
183: return (EIO);
184: /* Should we try and do this ?? */
185: if (ioflag & (IO_APPEND | IO_SYNC)) {
186: if (np->n_flag & NMODIFIED) {
187: np->n_flag &= ~NMODIFIED;
188: vinvalbuf(vp, TRUE);
189: }
190: if (ioflag & IO_APPEND) {
191: np->n_attrstamp = 0;
192: if (error = nfs_dogetattr(vp, &vattr, cred, 1))
193: return (error);
194: uio->uio_offset = np->n_size;
195: }
196: return (nfs_writerpc(vp, uio, cred, u.u_procp));
197: }
198: #ifdef notdef
199: cnt = uio->uio_resid;
200: osize = np->n_size;
201: #endif
202: if (uio->uio_offset < 0)
203: return (EINVAL);
204: if (uio->uio_resid == 0)
205: return (0);
206: /*
207: * Maybe this should be above the vnode op call, but so long as
208: * file servers have no limits, i don't think it matters
209: */
210: if (uio->uio_offset + uio->uio_resid >
211: u.u_rlimit[RLIMIT_FSIZE].rlim_cur) {
212: psignal(u.u_procp, SIGXFSZ);
213: return (EFBIG);
214: }
215: /*
216: * I use nm_rsize, not nm_wsize so that all buffer cache blocks
217: * will be the same size within a filesystem. nfs_writerpc will
218: * still use nm_wsize when sizing the rpc's.
219: */
220: biosize = VFSTONFS(vp->v_mount)->nm_rsize;
221: np->n_flag |= NMODIFIED;
222: do {
223: nfsstats.biocache_writes++;
224: lbn = uio->uio_offset / biosize;
225: on = uio->uio_offset & (biosize-1);
226: n = MIN((unsigned)(biosize - on), uio->uio_resid);
227: if (uio->uio_offset+n > np->n_size)
228: np->n_size = uio->uio_offset+n;
229: bn = lbn*(biosize/DEV_BSIZE);
230: again:
231: bp = getblk(vp, bn, biosize);
232: if (bp->b_wcred == NOCRED) {
233: crhold(cred);
234: bp->b_wcred = cred;
235: }
236: if (bp->b_dirtyend > 0) {
237: /*
238: * If the new write will leave a contiguous dirty
239: * area, just update the b_dirtyoff and b_dirtyend,
240: * otherwise force a write rpc of the old dirty area.
241: */
242: if (on <= bp->b_dirtyend && (on+n) >= bp->b_dirtyoff) {
243: bp->b_dirtyoff = MIN(on, bp->b_dirtyoff);
244: bp->b_dirtyend = MAX((on+n), bp->b_dirtyend);
245: } else {
246: bp->b_proc = u.u_procp;
247: if (error = bwrite(bp))
248: return (error);
249: goto again;
250: }
251: } else {
252: bp->b_dirtyoff = on;
253: bp->b_dirtyend = on+n;
254: }
255: if (error = uiomove(bp->b_un.b_addr + on, n, uio)) {
256: brelse(bp);
257: return (error);
258: }
259: if ((n+on) == biosize) {
260: bp->b_flags |= B_AGE;
261: bp->b_proc = (struct proc *)0;
262: bawrite(bp);
263: } else {
264: bp->b_proc = (struct proc *)0;
265: bdwrite(bp);
266: }
267: } while (error == 0 && uio->uio_resid > 0 && n != 0);
268: #ifdef notdef
269: /* Should we try and do this for nfs ?? */
270: if (error && (ioflag & IO_UNIT)) {
271: np->n_size = osize;
272: uio->uio_offset -= cnt - uio->uio_resid;
273: uio->uio_resid = cnt;
274: }
275: #endif
276: return (error);
277: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.