![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ufs_bmap.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / ufs|
Return to ufs_bmap.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / ufs |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution is only permitted until one year after the first shipment
6: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
7: * binary forms are permitted provided that: (1) source distributions retain
8: * this entire copyright notice and comment, and (2) distributions including
9: * binaries display the following acknowledgement: This product includes
10: * software developed by the University of California, Berkeley and its
11: * contributors'' in the documentation or other materials provided with the
12: * distribution and in all advertising materials mentioning features or use
13: * of this software. Neither the name of the University nor the names of
14: * its contributors may be used to endorse or promote products derived from
15: * this software without specific prior written permission.
16: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
17: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
18: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19: *
20: * @(#)ufs_bmap.c 7.10 (Berkeley) 6/28/90
21: */
22:
23: #include "param.h"
24: #include "systm.h"
25: #include "user.h"
26: #include "buf.h"
27: #include "proc.h"
28: #include "file.h"
29: #include "vnode.h"
30: #include "../ufs/quota.h"
31: #include "../ufs/inode.h"
32: #include "../ufs/fs.h"
33:
34: /*
35: * Bmap defines the structure of file system storage
36: * by returning the physical block number on a device
37: * given the inode and the logical block number in a file.
38: */
39: bmap(ip, bn, bnp)
40: register struct inode *ip;
41: register daddr_t bn;
42: daddr_t *bnp;
43: {
44: register struct fs *fs;
45: register daddr_t nb;
46: struct buf *bp;
47: daddr_t *bap;
48: int i, j, sh;
49: int error;
50:
51: if (bn < 0)
52: return (EFBIG);
53: fs = ip->i_fs;
54:
55: /*
56: * The first NDADDR blocks are direct blocks
57: */
58: if (bn < NDADDR) {
59: nb = ip->i_db[bn];
60: if (nb == 0) {
61: *bnp = (daddr_t)-1;
62: return (0);
63: }
64: *bnp = fsbtodb(fs, nb);
65: return (0);
66: }
67: /*
68: * Determine the number of levels of indirection.
69: */
70: sh = 1;
71: bn -= NDADDR;
72: for (j = NIADDR; j > 0; j--) {
73: sh *= NINDIR(fs);
74: if (bn < sh)
75: break;
76: bn -= sh;
77: }
78: if (j == 0)
79: return (EFBIG);
80: /*
81: * Fetch through the indirect blocks.
82: */
83: nb = ip->i_ib[NIADDR - j];
84: if (nb == 0) {
85: *bnp = (daddr_t)-1;
86: return (0);
87: }
88: for (; j <= NIADDR; j++) {
89: if (error = bread(ip->i_devvp, fsbtodb(fs, nb),
90: (int)fs->fs_bsize, NOCRED, &bp)) {
91: brelse(bp);
92: return (error);
93: }
94: bap = bp->b_un.b_daddr;
95: sh /= NINDIR(fs);
96: i = (bn / sh) % NINDIR(fs);
97: nb = bap[i];
98: if (nb == 0) {
99: *bnp = (daddr_t)-1;
100: brelse(bp);
101: return (0);
102: }
103: brelse(bp);
104: }
105: *bnp = fsbtodb(fs, nb);
106: return (0);
107: }
108:
109: /*
110: * Balloc defines the structure of file system storage
111: * by allocating the physical blocks on a device given
112: * the inode and the logical block number in a file.
113: */
114: balloc(ip, bn, size, bpp, flags)
115: register struct inode *ip;
116: register daddr_t bn;
117: int size;
118: struct buf **bpp;
119: int flags;
120: {
121: register struct fs *fs;
122: register daddr_t nb;
123: struct buf *bp, *nbp;
124: struct vnode *vp = ITOV(ip);
125: int osize, nsize, i, j, sh, error;
126: daddr_t newb, lbn, *bap, pref, blkpref();
127:
128: *bpp = (struct buf *)0;
129: if (bn < 0)
130: return (EFBIG);
131: fs = ip->i_fs;
132:
133: /*
134: * If the next write will extend the file into a new block,
135: * and the file is currently composed of a fragment
136: * this fragment has to be extended to be a full block.
137: */
138: nb = lblkno(fs, ip->i_size);
139: if (nb < NDADDR && nb < bn) {
140: osize = blksize(fs, ip, nb);
141: if (osize < fs->fs_bsize && osize > 0) {
142: error = realloccg(ip, nb,
143: blkpref(ip, nb, (int)nb, &ip->i_db[0]),
144: osize, (int)fs->fs_bsize, &bp);
145: if (error)
146: return (error);
147: ip->i_size = (nb + 1) * fs->fs_bsize;
148: ip->i_db[nb] = dbtofsb(fs, bp->b_blkno);
149: ip->i_flag |= IUPD|ICHG;
150: if (flags & B_SYNC)
151: bwrite(bp);
152: else
153: bawrite(bp);
154: }
155: }
156: /*
157: * The first NDADDR blocks are direct blocks
158: */
159: if (bn < NDADDR) {
160: nb = ip->i_db[bn];
161: if (nb != 0 && ip->i_size >= (bn + 1) * fs->fs_bsize) {
162: error = bread(vp, bn, fs->fs_bsize, NOCRED, &bp);
163: if (error) {
164: brelse(bp);
165: return (error);
166: }
167: *bpp = bp;
168: return (0);
169: }
170: if (nb != 0) {
171: /*
172: * Consider need to reallocate a fragment.
173: */
174: osize = fragroundup(fs, blkoff(fs, ip->i_size));
175: nsize = fragroundup(fs, size);
176: if (nsize <= osize) {
177: error = bread(vp, bn, osize, NOCRED, &bp);
178: if (error) {
179: brelse(bp);
180: return (error);
181: }
182: } else {
183: error = realloccg(ip, bn,
184: blkpref(ip, bn, (int)bn, &ip->i_db[0]),
185: osize, nsize, &bp);
186: if (error)
187: return (error);
188: }
189: } else {
190: if (ip->i_size < (bn + 1) * fs->fs_bsize)
191: nsize = fragroundup(fs, size);
192: else
193: nsize = fs->fs_bsize;
194: error = alloc(ip, bn,
195: blkpref(ip, bn, (int)bn, &ip->i_db[0]),
196: nsize, &newb);
197: if (error)
198: return (error);
199: bp = getblk(vp, bn, nsize);
200: bp->b_blkno = fsbtodb(fs, newb);
201: if (flags & B_CLRBUF)
202: clrbuf(bp);
203: }
204: ip->i_db[bn] = dbtofsb(fs, bp->b_blkno);
205: ip->i_flag |= IUPD|ICHG;
206: *bpp = bp;
207: return (0);
208: }
209: /*
210: * Determine the number of levels of indirection.
211: */
212: pref = 0;
213: sh = 1;
214: lbn = bn;
215: bn -= NDADDR;
216: for (j = NIADDR; j > 0; j--) {
217: sh *= NINDIR(fs);
218: if (bn < sh)
219: break;
220: bn -= sh;
221: }
222: if (j == 0)
223: return (EFBIG);
224: /*
225: * Fetch the first indirect block allocating if necessary.
226: */
227: nb = ip->i_ib[NIADDR - j];
228: if (nb == 0) {
229: pref = blkpref(ip, lbn, 0, (daddr_t *)0);
230: if (error = alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb))
231: return (error);
232: nb = newb;
233: bp = getblk(ip->i_devvp, fsbtodb(fs, nb), fs->fs_bsize);
234: clrbuf(bp);
235: /*
236: * Write synchronously so that indirect blocks
237: * never point at garbage.
238: */
239: if (error = bwrite(bp)) {
240: blkfree(ip, nb, fs->fs_bsize);
241: return (error);
242: }
243: ip->i_ib[NIADDR - j] = nb;
244: ip->i_flag |= IUPD|ICHG;
245: }
246: /*
247: * Fetch through the indirect blocks, allocating as necessary.
248: */
249: for (; ; j++) {
250: error = bread(ip->i_devvp, fsbtodb(fs, nb),
251: (int)fs->fs_bsize, NOCRED, &bp);
252: if (error) {
253: brelse(bp);
254: return (error);
255: }
256: bap = bp->b_un.b_daddr;
257: sh /= NINDIR(fs);
258: i = (bn / sh) % NINDIR(fs);
259: nb = bap[i];
260: if (j == NIADDR)
261: break;
262: if (nb != 0) {
263: brelse(bp);
264: continue;
265: }
266: if (pref == 0)
267: pref = blkpref(ip, lbn, 0, (daddr_t *)0);
268: if (error = alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb)) {
269: brelse(bp);
270: return (error);
271: }
272: nb = newb;
273: nbp = getblk(ip->i_devvp, fsbtodb(fs, nb), fs->fs_bsize);
274: clrbuf(nbp);
275: /*
276: * Write synchronously so that indirect blocks
277: * never point at garbage.
278: */
279: if (error = bwrite(nbp)) {
280: blkfree(ip, nb, fs->fs_bsize);
281: brelse(bp);
282: return (error);
283: }
284: bap[i] = nb;
285: /*
286: * If required, write synchronously, otherwise use
287: * delayed write. If this is the first instance of
288: * the delayed write, reassociate the buffer with the
289: * file so it will be written if the file is sync'ed.
290: */
291: if (flags & B_SYNC) {
292: bwrite(bp);
293: } else if (bp->b_flags & B_DELWRI) {
294: bdwrite(bp);
295: } else {
296: bdwrite(bp);
297: reassignbuf(bp, vp);
298: }
299: }
300: /*
301: * Get the data block, allocating if necessary.
302: */
303: if (nb == 0) {
304: pref = blkpref(ip, lbn, i, &bap[0]);
305: if (error = alloc(ip, lbn, pref, (int)fs->fs_bsize, &newb)) {
306: brelse(bp);
307: return (error);
308: }
309: nb = newb;
310: nbp = getblk(vp, lbn, fs->fs_bsize);
311: nbp->b_blkno = fsbtodb(fs, nb);
312: if (flags & B_CLRBUF)
313: clrbuf(nbp);
314: bap[i] = nb;
315: /*
316: * If required, write synchronously, otherwise use
317: * delayed write. If this is the first instance of
318: * the delayed write, reassociate the buffer with the
319: * file so it will be written if the file is sync'ed.
320: */
321: if (flags & B_SYNC) {
322: bwrite(bp);
323: } else if (bp->b_flags & B_DELWRI) {
324: bdwrite(bp);
325: } else {
326: bdwrite(bp);
327: reassignbuf(bp, vp);
328: }
329: *bpp = nbp;
330: return (0);
331: }
332: brelse(bp);
333: if (flags & B_CLRBUF) {
334: error = bread(vp, lbn, (int)fs->fs_bsize, NOCRED, &nbp);
335: if (error) {
336: brelse(nbp);
337: return (error);
338: }
339: } else {
340: nbp = getblk(vp, lbn, fs->fs_bsize);
341: nbp->b_blkno = fsbtodb(fs, nb);
342: }
343: *bpp = nbp;
344: return (0);
345: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.