ext2fs_inode.c revision 1.8 1 1.8 perry /* $NetBSD: ext2fs_inode.c,v 1.8 1998/08/09 20:15:38 perry Exp $ */
2 1.1 bouyer
3 1.1 bouyer /*
4 1.1 bouyer * Copyright (c) 1997 Manuel Bouyer.
5 1.1 bouyer * Copyright (c) 1982, 1986, 1989, 1993
6 1.1 bouyer * The Regents of the University of California. All rights reserved.
7 1.1 bouyer *
8 1.1 bouyer * Redistribution and use in source and binary forms, with or without
9 1.1 bouyer * modification, are permitted provided that the following conditions
10 1.1 bouyer * are met:
11 1.1 bouyer * 1. Redistributions of source code must retain the above copyright
12 1.1 bouyer * notice, this list of conditions and the following disclaimer.
13 1.1 bouyer * 2. Redistributions in binary form must reproduce the above copyright
14 1.1 bouyer * notice, this list of conditions and the following disclaimer in the
15 1.1 bouyer * documentation and/or other materials provided with the distribution.
16 1.1 bouyer * 3. All advertising materials mentioning features or use of this software
17 1.1 bouyer * must display the following acknowledgement:
18 1.1 bouyer * This product includes software developed by the University of
19 1.1 bouyer * California, Berkeley and its contributors.
20 1.1 bouyer * 4. Neither the name of the University nor the names of its contributors
21 1.1 bouyer * may be used to endorse or promote products derived from this software
22 1.1 bouyer * without specific prior written permission.
23 1.1 bouyer *
24 1.1 bouyer * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 1.1 bouyer * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 1.1 bouyer * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 1.1 bouyer * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 1.1 bouyer * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 1.1 bouyer * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 1.1 bouyer * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 1.1 bouyer * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 1.1 bouyer * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 1.1 bouyer * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 1.1 bouyer * SUCH DAMAGE.
35 1.1 bouyer *
36 1.1 bouyer * @(#)ffs_inode.c 8.8 (Berkeley) 10/19/94
37 1.1 bouyer * Modified for ext2fs by Manuel Bouyer.
38 1.1 bouyer */
39 1.5 mrg
40 1.5 mrg #include "opt_uvm.h"
41 1.1 bouyer
42 1.1 bouyer #include <sys/param.h>
43 1.1 bouyer #include <sys/systm.h>
44 1.1 bouyer #include <sys/mount.h>
45 1.1 bouyer #include <sys/proc.h>
46 1.1 bouyer #include <sys/file.h>
47 1.1 bouyer #include <sys/buf.h>
48 1.1 bouyer #include <sys/vnode.h>
49 1.1 bouyer #include <sys/kernel.h>
50 1.1 bouyer #include <sys/malloc.h>
51 1.1 bouyer #include <sys/trace.h>
52 1.1 bouyer #include <sys/resourcevar.h>
53 1.1 bouyer
54 1.1 bouyer #include <vm/vm.h>
55 1.4 mrg #if defined(UVM)
56 1.4 mrg #include <uvm/uvm_extern.h>
57 1.4 mrg #endif
58 1.1 bouyer
59 1.1 bouyer #include <ufs/ufs/quota.h>
60 1.1 bouyer #include <ufs/ufs/inode.h>
61 1.1 bouyer #include <ufs/ufs/ufsmount.h>
62 1.1 bouyer #include <ufs/ufs/ufs_extern.h>
63 1.1 bouyer
64 1.1 bouyer #include <ufs/ext2fs/ext2fs.h>
65 1.1 bouyer #include <ufs/ext2fs/ext2fs_extern.h>
66 1.1 bouyer
67 1.6 fvdl static int ext2fs_indirtrunc __P((struct inode *, ufs_daddr_t, ufs_daddr_t,
68 1.6 fvdl ufs_daddr_t, int, long *));
69 1.1 bouyer
70 1.1 bouyer /*
71 1.1 bouyer * Last reference to an inode. If necessary, write or delete it.
72 1.1 bouyer */
73 1.1 bouyer int
74 1.1 bouyer ext2fs_inactive(v)
75 1.1 bouyer void *v;
76 1.1 bouyer {
77 1.1 bouyer struct vop_inactive_args /* {
78 1.1 bouyer struct vnode *a_vp;
79 1.6 fvdl struct proc *a_p;
80 1.1 bouyer } */ *ap = v;
81 1.6 fvdl struct vnode *vp = ap->a_vp;
82 1.6 fvdl struct inode *ip = VTOI(vp);
83 1.6 fvdl struct proc *p = ap->a_p;
84 1.1 bouyer struct timespec ts;
85 1.6 fvdl int error = 0;
86 1.1 bouyer extern int prtactive;
87 1.1 bouyer
88 1.1 bouyer if (prtactive && vp->v_usecount != 0)
89 1.7 mikel vprint("ext2fs_inactive: pushing active", vp);
90 1.1 bouyer /* Get rid of inodes related to stale file handles. */
91 1.6 fvdl if (ip->i_e2fs_mode == 0 || ip->i_e2fs_dtime != 0)
92 1.6 fvdl goto out;
93 1.1 bouyer
94 1.1 bouyer error = 0;
95 1.1 bouyer if (ip->i_e2fs_nlink == 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
96 1.1 bouyer error = VOP_TRUNCATE(vp, (off_t)0, 0, NOCRED, NULL);
97 1.1 bouyer TIMEVAL_TO_TIMESPEC(&time, &ts);
98 1.1 bouyer ip->i_e2fs_dtime = ts.tv_sec;
99 1.1 bouyer ip->i_flag |= IN_CHANGE | IN_UPDATE;
100 1.1 bouyer VOP_VFREE(vp, ip->i_number, ip->i_e2fs_mode);
101 1.1 bouyer }
102 1.1 bouyer if (ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) {
103 1.1 bouyer TIMEVAL_TO_TIMESPEC(&time, &ts);
104 1.1 bouyer VOP_UPDATE(vp, &ts, &ts, 0);
105 1.1 bouyer }
106 1.6 fvdl out:
107 1.6 fvdl VOP_UNLOCK(vp, 0);
108 1.1 bouyer /*
109 1.1 bouyer * If we are done with the inode, reclaim it
110 1.1 bouyer * so that it can be reused immediately.
111 1.1 bouyer */
112 1.6 fvdl if (ip->i_e2fs_dtime != 0)
113 1.6 fvdl vrecycle(vp, (struct simplelock *)0, p);
114 1.1 bouyer return (error);
115 1.1 bouyer }
116 1.1 bouyer
117 1.1 bouyer
118 1.1 bouyer /*
119 1.1 bouyer * Update the access, modified, and inode change times as specified by the
120 1.1 bouyer * IACCESS, IUPDATE, and ICHANGE flags respectively. The IMODIFIED flag is
121 1.1 bouyer * used to specify that the inode needs to be updated but that the times have
122 1.1 bouyer * already been set. The access and modified times are taken from the second
123 1.1 bouyer * and third parameters; the inode change time is always taken from the current
124 1.1 bouyer * time. If waitfor is set, then wait for the disk write of the inode to
125 1.1 bouyer * complete.
126 1.1 bouyer */
127 1.1 bouyer int
128 1.1 bouyer ext2fs_update(v)
129 1.1 bouyer void *v;
130 1.1 bouyer {
131 1.1 bouyer struct vop_update_args /* {
132 1.1 bouyer struct vnode *a_vp;
133 1.1 bouyer struct timespec *a_access;
134 1.1 bouyer struct timespec *a_modify;
135 1.1 bouyer int a_waitfor;
136 1.1 bouyer } */ *ap = v;
137 1.1 bouyer register struct m_ext2fs *fs;
138 1.1 bouyer struct buf *bp;
139 1.1 bouyer struct inode *ip;
140 1.1 bouyer int error;
141 1.1 bouyer struct timespec ts;
142 1.1 bouyer
143 1.1 bouyer if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)
144 1.1 bouyer return (0);
145 1.1 bouyer ip = VTOI(ap->a_vp);
146 1.1 bouyer TIMEVAL_TO_TIMESPEC(&time, &ts);
147 1.1 bouyer EXT2FS_ITIMES(ip, ap->a_access, ap->a_modify, &ts);
148 1.1 bouyer if ((ip->i_flag & IN_MODIFIED) == 0)
149 1.1 bouyer return (0);
150 1.1 bouyer ip->i_flag &= ~IN_MODIFIED;
151 1.1 bouyer fs = ip->i_e2fs;
152 1.1 bouyer error = bread(ip->i_devvp,
153 1.1 bouyer fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
154 1.1 bouyer (int)fs->e2fs_bsize, NOCRED, &bp);
155 1.1 bouyer if (error) {
156 1.1 bouyer brelse(bp);
157 1.1 bouyer return (error);
158 1.1 bouyer }
159 1.3 bouyer e2fs_isave(&ip->i_din.e2fs_din,
160 1.3 bouyer (struct ext2fs_dinode *)bp->b_data + ino_to_fsbo(fs, ip->i_number));
161 1.6 fvdl if (ap->a_waitfor && (ap->a_vp->v_mount->mnt_flag & MNT_ASYNC) == 0)
162 1.1 bouyer return (bwrite(bp));
163 1.1 bouyer else {
164 1.1 bouyer bdwrite(bp);
165 1.1 bouyer return (0);
166 1.1 bouyer }
167 1.1 bouyer }
168 1.1 bouyer
169 1.1 bouyer #define SINGLE 0 /* index of single indirect block */
170 1.1 bouyer #define DOUBLE 1 /* index of double indirect block */
171 1.1 bouyer #define TRIPLE 2 /* index of triple indirect block */
172 1.1 bouyer /*
173 1.1 bouyer * Truncate the inode oip to at most length size, freeing the
174 1.1 bouyer * disk blocks.
175 1.1 bouyer */
176 1.1 bouyer int
177 1.1 bouyer ext2fs_truncate(v)
178 1.1 bouyer void *v;
179 1.1 bouyer {
180 1.1 bouyer struct vop_truncate_args /* {
181 1.1 bouyer struct vnode *a_vp;
182 1.1 bouyer off_t a_length;
183 1.1 bouyer int a_flags;
184 1.1 bouyer struct ucred *a_cred;
185 1.1 bouyer struct proc *a_p;
186 1.1 bouyer } */ *ap = v;
187 1.1 bouyer register struct vnode *ovp = ap->a_vp;
188 1.6 fvdl register ufs_daddr_t lastblock;
189 1.1 bouyer register struct inode *oip;
190 1.6 fvdl ufs_daddr_t bn, lbn, lastiblock[NIADDR], indir_lbn[NIADDR];
191 1.6 fvdl ufs_daddr_t oldblks[NDADDR + NIADDR], newblks[NDADDR + NIADDR];
192 1.1 bouyer off_t length = ap->a_length;
193 1.1 bouyer register struct m_ext2fs *fs;
194 1.1 bouyer struct buf *bp;
195 1.1 bouyer int offset, size, level;
196 1.1 bouyer long count, nblocks, vflags, blocksreleased = 0;
197 1.1 bouyer struct timespec ts;
198 1.1 bouyer register int i;
199 1.1 bouyer int aflags, error, allerror;
200 1.1 bouyer off_t osize;
201 1.1 bouyer
202 1.1 bouyer if (length < 0)
203 1.1 bouyer return (EINVAL);
204 1.1 bouyer
205 1.1 bouyer oip = VTOI(ovp);
206 1.1 bouyer TIMEVAL_TO_TIMESPEC(&time, &ts);
207 1.1 bouyer if (ovp->v_type == VLNK &&
208 1.1 bouyer (oip->i_e2fs_size < ovp->v_mount->mnt_maxsymlinklen ||
209 1.1 bouyer (ovp->v_mount->mnt_maxsymlinklen == 0 &&
210 1.1 bouyer oip->i_e2fs_nblock == 0))) {
211 1.1 bouyer #ifdef DIAGNOSTIC
212 1.1 bouyer if (length != 0)
213 1.1 bouyer panic("ext2fs_truncate: partial truncate of symlink");
214 1.1 bouyer #endif
215 1.8 perry memset((char *)&oip->i_din.e2fs_din.e2di_shortlink, 0,
216 1.1 bouyer (u_int)oip->i_e2fs_size);
217 1.1 bouyer oip->i_e2fs_size = 0;
218 1.1 bouyer oip->i_flag |= IN_CHANGE | IN_UPDATE;
219 1.1 bouyer return (VOP_UPDATE(ovp, &ts, &ts, 1));
220 1.1 bouyer }
221 1.1 bouyer if (oip->i_e2fs_size == length) {
222 1.1 bouyer oip->i_flag |= IN_CHANGE | IN_UPDATE;
223 1.1 bouyer return (VOP_UPDATE(ovp, &ts, &ts, 0));
224 1.1 bouyer }
225 1.1 bouyer fs = oip->i_e2fs;
226 1.1 bouyer osize = oip->i_e2fs_size;
227 1.1 bouyer /*
228 1.1 bouyer * Lengthen the size of the file. We must ensure that the
229 1.1 bouyer * last byte of the file is allocated. Since the smallest
230 1.1 bouyer * value of osize is 0, length will be at least 1.
231 1.1 bouyer */
232 1.1 bouyer if (osize < length) {
233 1.1 bouyer #if 0 /* XXX */
234 1.1 bouyer if (length > fs->fs_maxfilesize)
235 1.1 bouyer return (EFBIG);
236 1.1 bouyer #endif
237 1.1 bouyer offset = blkoff(fs, length - 1);
238 1.1 bouyer lbn = lblkno(fs, length - 1);
239 1.1 bouyer aflags = B_CLRBUF;
240 1.1 bouyer if (ap->a_flags & IO_SYNC)
241 1.1 bouyer aflags |= B_SYNC;
242 1.1 bouyer error = ext2fs_balloc(oip, lbn, offset + 1, ap->a_cred, &bp,
243 1.1 bouyer aflags);
244 1.1 bouyer if (error)
245 1.1 bouyer return (error);
246 1.1 bouyer oip->i_e2fs_size = length;
247 1.4 mrg #if defined(UVM)
248 1.4 mrg uvm_vnp_setsize(ovp, length);
249 1.4 mrg (void) uvm_vnp_uncache(ovp);
250 1.4 mrg #else
251 1.2 drochner vnode_pager_setsize(ovp, length);
252 1.1 bouyer (void) vnode_pager_uncache(ovp);
253 1.4 mrg #endif
254 1.1 bouyer if (aflags & B_SYNC)
255 1.1 bouyer bwrite(bp);
256 1.1 bouyer else
257 1.1 bouyer bawrite(bp);
258 1.1 bouyer oip->i_flag |= IN_CHANGE | IN_UPDATE;
259 1.1 bouyer return (VOP_UPDATE(ovp, &ts, &ts, 1));
260 1.1 bouyer }
261 1.1 bouyer /*
262 1.1 bouyer * Shorten the size of the file. If the file is not being
263 1.1 bouyer * truncated to a block boundry, the contents of the
264 1.1 bouyer * partial block following the end of the file must be
265 1.1 bouyer * zero'ed in case it ever become accessable again because
266 1.1 bouyer * of subsequent file growth.
267 1.1 bouyer */
268 1.1 bouyer offset = blkoff(fs, length);
269 1.1 bouyer if (offset == 0) {
270 1.1 bouyer oip->i_e2fs_size = length;
271 1.1 bouyer } else {
272 1.1 bouyer lbn = lblkno(fs, length);
273 1.1 bouyer aflags = B_CLRBUF;
274 1.1 bouyer if (ap->a_flags & IO_SYNC)
275 1.1 bouyer aflags |= B_SYNC;
276 1.1 bouyer error = ext2fs_balloc(oip, lbn, offset, ap->a_cred, &bp, aflags);
277 1.1 bouyer if (error)
278 1.1 bouyer return (error);
279 1.1 bouyer oip->i_e2fs_size = length;
280 1.1 bouyer size = fs->e2fs_bsize;
281 1.4 mrg #if defined(UVM)
282 1.4 mrg (void) uvm_vnp_uncache(ovp);
283 1.4 mrg #else
284 1.1 bouyer (void) vnode_pager_uncache(ovp);
285 1.4 mrg #endif
286 1.8 perry memset((char *)bp->b_data + offset, 0, (u_int)(size - offset));
287 1.1 bouyer allocbuf(bp, size);
288 1.1 bouyer if (aflags & B_SYNC)
289 1.1 bouyer bwrite(bp);
290 1.1 bouyer else
291 1.1 bouyer bawrite(bp);
292 1.1 bouyer }
293 1.6 fvdl #if defined(UVM)
294 1.6 fvdl uvm_vnp_setsize(ovp, length);
295 1.6 fvdl #else
296 1.6 fvdl vnode_pager_setsize(ovp, length);
297 1.6 fvdl #endif
298 1.1 bouyer /*
299 1.1 bouyer * Calculate index into inode's block list of
300 1.1 bouyer * last direct and indirect blocks (if any)
301 1.1 bouyer * which we want to keep. Lastblock is -1 when
302 1.1 bouyer * the file is truncated to 0.
303 1.1 bouyer */
304 1.1 bouyer lastblock = lblkno(fs, length + fs->e2fs_bsize - 1) - 1;
305 1.1 bouyer lastiblock[SINGLE] = lastblock - NDADDR;
306 1.1 bouyer lastiblock[DOUBLE] = lastiblock[SINGLE] - NINDIR(fs);
307 1.1 bouyer lastiblock[TRIPLE] = lastiblock[DOUBLE] - NINDIR(fs) * NINDIR(fs);
308 1.1 bouyer nblocks = btodb(fs->e2fs_bsize);
309 1.1 bouyer /*
310 1.1 bouyer * Update file and block pointers on disk before we start freeing
311 1.1 bouyer * blocks. If we crash before free'ing blocks below, the blocks
312 1.1 bouyer * will be returned to the free list. lastiblock values are also
313 1.1 bouyer * normalized to -1 for calls to ext2fs_indirtrunc below.
314 1.1 bouyer */
315 1.8 perry memcpy((caddr_t)oldblks, (caddr_t)&oip->i_e2fs_blocks[0], sizeof oldblks);
316 1.1 bouyer for (level = TRIPLE; level >= SINGLE; level--)
317 1.1 bouyer if (lastiblock[level] < 0) {
318 1.1 bouyer oip->i_e2fs_blocks[NDADDR + level] = 0;
319 1.1 bouyer lastiblock[level] = -1;
320 1.1 bouyer }
321 1.1 bouyer for (i = NDADDR - 1; i > lastblock; i--)
322 1.1 bouyer oip->i_e2fs_blocks[i] = 0;
323 1.1 bouyer oip->i_flag |= IN_CHANGE | IN_UPDATE;
324 1.1 bouyer if ((error = VOP_UPDATE(ovp, &ts, &ts, 1)) != 0)
325 1.1 bouyer allerror = error;
326 1.1 bouyer /*
327 1.1 bouyer * Having written the new inode to disk, save its new configuration
328 1.1 bouyer * and put back the old block pointers long enough to process them.
329 1.1 bouyer * Note that we save the new block configuration so we can check it
330 1.1 bouyer * when we are done.
331 1.1 bouyer */
332 1.8 perry memcpy((caddr_t)newblks, (caddr_t)&oip->i_e2fs_blocks[0], sizeof newblks);
333 1.8 perry memcpy((caddr_t)&oip->i_e2fs_blocks[0], (caddr_t)oldblks, sizeof oldblks);
334 1.1 bouyer oip->i_e2fs_size = osize;
335 1.1 bouyer vflags = ((length > 0) ? V_SAVE : 0) | V_SAVEMETA;
336 1.1 bouyer allerror = vinvalbuf(ovp, vflags, ap->a_cred, ap->a_p, 0, 0);
337 1.1 bouyer
338 1.1 bouyer /*
339 1.1 bouyer * Indirect blocks first.
340 1.1 bouyer */
341 1.1 bouyer indir_lbn[SINGLE] = -NDADDR;
342 1.1 bouyer indir_lbn[DOUBLE] = indir_lbn[SINGLE] - NINDIR(fs) -1;
343 1.1 bouyer indir_lbn[TRIPLE] = indir_lbn[DOUBLE] - NINDIR(fs) * NINDIR(fs) - 1;
344 1.1 bouyer for (level = TRIPLE; level >= SINGLE; level--) {
345 1.3 bouyer bn = fs2h32(oip->i_e2fs_blocks[NDADDR + level]);
346 1.1 bouyer if (bn != 0) {
347 1.1 bouyer error = ext2fs_indirtrunc(oip, indir_lbn[level],
348 1.1 bouyer fsbtodb(fs, bn), lastiblock[level], level, &count);
349 1.1 bouyer if (error)
350 1.1 bouyer allerror = error;
351 1.1 bouyer blocksreleased += count;
352 1.1 bouyer if (lastiblock[level] < 0) {
353 1.1 bouyer oip->i_e2fs_blocks[NDADDR + level] = 0;
354 1.1 bouyer ext2fs_blkfree(oip, bn);
355 1.1 bouyer blocksreleased += nblocks;
356 1.1 bouyer }
357 1.1 bouyer }
358 1.1 bouyer if (lastiblock[level] >= 0)
359 1.1 bouyer goto done;
360 1.1 bouyer }
361 1.1 bouyer
362 1.1 bouyer /*
363 1.1 bouyer * All whole direct blocks or frags.
364 1.1 bouyer */
365 1.1 bouyer for (i = NDADDR - 1; i > lastblock; i--) {
366 1.3 bouyer bn = fs2h32(oip->i_e2fs_blocks[i]);
367 1.1 bouyer if (bn == 0)
368 1.1 bouyer continue;
369 1.1 bouyer oip->i_e2fs_blocks[i] = 0;
370 1.1 bouyer ext2fs_blkfree(oip, bn);
371 1.1 bouyer blocksreleased += btodb(fs->e2fs_bsize);
372 1.1 bouyer }
373 1.1 bouyer if (lastblock < 0)
374 1.1 bouyer goto done;
375 1.1 bouyer
376 1.1 bouyer done:
377 1.1 bouyer #ifdef DIAGNOSTIC
378 1.1 bouyer for (level = SINGLE; level <= TRIPLE; level++)
379 1.3 bouyer if (newblks[NDADDR + level] !=
380 1.3 bouyer fs2h32(oip->i_e2fs_blocks[NDADDR + level]))
381 1.1 bouyer panic("itrunc1");
382 1.1 bouyer for (i = 0; i < NDADDR; i++)
383 1.3 bouyer if (newblks[i] != fs2h32(oip->i_e2fs_blocks[i]))
384 1.1 bouyer panic("itrunc2");
385 1.1 bouyer if (length == 0 &&
386 1.1 bouyer (ovp->v_dirtyblkhd.lh_first || ovp->v_cleanblkhd.lh_first))
387 1.1 bouyer panic("itrunc3");
388 1.1 bouyer #endif /* DIAGNOSTIC */
389 1.1 bouyer /*
390 1.1 bouyer * Put back the real size.
391 1.1 bouyer */
392 1.1 bouyer oip->i_e2fs_size = length;
393 1.1 bouyer oip->i_e2fs_nblock -= blocksreleased;
394 1.1 bouyer if (oip->i_e2fs_nblock < 0) /* sanity */
395 1.1 bouyer oip->i_e2fs_nblock = 0;
396 1.1 bouyer oip->i_flag |= IN_CHANGE;
397 1.1 bouyer return (allerror);
398 1.1 bouyer }
399 1.1 bouyer
400 1.1 bouyer /*
401 1.1 bouyer * Release blocks associated with the inode ip and stored in the indirect
402 1.1 bouyer * block bn. Blocks are free'd in LIFO order up to (but not including)
403 1.1 bouyer * lastbn. If level is greater than SINGLE, the block is an indirect block
404 1.1 bouyer * and recursive calls to indirtrunc must be used to cleanse other indirect
405 1.1 bouyer * blocks.
406 1.1 bouyer *
407 1.1 bouyer * NB: triple indirect blocks are untested.
408 1.1 bouyer */
409 1.1 bouyer static int
410 1.1 bouyer ext2fs_indirtrunc(ip, lbn, dbn, lastbn, level, countp)
411 1.1 bouyer register struct inode *ip;
412 1.6 fvdl ufs_daddr_t lbn, lastbn;
413 1.6 fvdl ufs_daddr_t dbn;
414 1.1 bouyer int level;
415 1.1 bouyer long *countp;
416 1.1 bouyer {
417 1.1 bouyer register int i;
418 1.1 bouyer struct buf *bp;
419 1.1 bouyer register struct m_ext2fs *fs = ip->i_e2fs;
420 1.6 fvdl register ufs_daddr_t *bap;
421 1.1 bouyer struct vnode *vp;
422 1.6 fvdl ufs_daddr_t *copy = NULL, nb, nlbn, last;
423 1.1 bouyer long blkcount, factor;
424 1.1 bouyer int nblocks, blocksreleased = 0;
425 1.1 bouyer int error = 0, allerror = 0;
426 1.1 bouyer
427 1.1 bouyer /*
428 1.1 bouyer * Calculate index in current block of last
429 1.1 bouyer * block to be kept. -1 indicates the entire
430 1.1 bouyer * block so we need not calculate the index.
431 1.1 bouyer */
432 1.1 bouyer factor = 1;
433 1.1 bouyer for (i = SINGLE; i < level; i++)
434 1.1 bouyer factor *= NINDIR(fs);
435 1.1 bouyer last = lastbn;
436 1.1 bouyer if (lastbn > 0)
437 1.1 bouyer last /= factor;
438 1.1 bouyer nblocks = btodb(fs->e2fs_bsize);
439 1.1 bouyer /*
440 1.1 bouyer * Get buffer of block pointers, zero those entries corresponding
441 1.1 bouyer * to blocks to be free'd, and update on disk copy first. Since
442 1.1 bouyer * double(triple) indirect before single(double) indirect, calls
443 1.1 bouyer * to bmap on these blocks will fail. However, we already have
444 1.1 bouyer * the on disk address, so we have to set the b_blkno field
445 1.1 bouyer * explicitly instead of letting bread do everything for us.
446 1.1 bouyer */
447 1.1 bouyer vp = ITOV(ip);
448 1.1 bouyer bp = getblk(vp, lbn, (int)fs->e2fs_bsize, 0, 0);
449 1.1 bouyer if (bp->b_flags & (B_DONE | B_DELWRI)) {
450 1.1 bouyer /* Braces must be here in case trace evaluates to nothing. */
451 1.1 bouyer trace(TR_BREADHIT, pack(vp, fs->e2fs_bsize), lbn);
452 1.1 bouyer } else {
453 1.1 bouyer trace(TR_BREADMISS, pack(vp, fs->e2fs_bsize), lbn);
454 1.1 bouyer curproc->p_stats->p_ru.ru_inblock++; /* pay for read */
455 1.1 bouyer bp->b_flags |= B_READ;
456 1.1 bouyer if (bp->b_bcount > bp->b_bufsize)
457 1.1 bouyer panic("ext2fs_indirtrunc: bad buffer size");
458 1.1 bouyer bp->b_blkno = dbn;
459 1.1 bouyer VOP_STRATEGY(bp);
460 1.1 bouyer error = biowait(bp);
461 1.1 bouyer }
462 1.1 bouyer if (error) {
463 1.1 bouyer brelse(bp);
464 1.1 bouyer *countp = 0;
465 1.1 bouyer return (error);
466 1.1 bouyer }
467 1.1 bouyer
468 1.6 fvdl bap = (ufs_daddr_t *)bp->b_data;
469 1.1 bouyer if (lastbn != -1) {
470 1.6 fvdl MALLOC(copy, ufs_daddr_t *, fs->e2fs_bsize, M_TEMP, M_WAITOK);
471 1.8 perry memcpy((caddr_t)copy, (caddr_t)bap, (u_int)fs->e2fs_bsize);
472 1.8 perry memset((caddr_t)&bap[last + 1], 0,
473 1.1 bouyer (u_int)(NINDIR(fs) - (last + 1)) * sizeof (u_int32_t));
474 1.1 bouyer error = bwrite(bp);
475 1.1 bouyer if (error)
476 1.1 bouyer allerror = error;
477 1.1 bouyer bap = copy;
478 1.1 bouyer }
479 1.1 bouyer
480 1.1 bouyer /*
481 1.1 bouyer * Recursively free totally unused blocks.
482 1.1 bouyer */
483 1.1 bouyer for (i = NINDIR(fs) - 1,
484 1.1 bouyer nlbn = lbn + 1 - i * factor; i > last;
485 1.1 bouyer i--, nlbn += factor) {
486 1.3 bouyer nb = fs2h32(bap[i]);
487 1.1 bouyer if (nb == 0)
488 1.1 bouyer continue;
489 1.1 bouyer if (level > SINGLE) {
490 1.1 bouyer error = ext2fs_indirtrunc(ip, nlbn, fsbtodb(fs, nb),
491 1.6 fvdl (ufs_daddr_t)-1, level - 1,
492 1.1 bouyer &blkcount);
493 1.1 bouyer if (error)
494 1.1 bouyer allerror = error;
495 1.1 bouyer blocksreleased += blkcount;
496 1.1 bouyer }
497 1.1 bouyer ext2fs_blkfree(ip, nb);
498 1.1 bouyer blocksreleased += nblocks;
499 1.1 bouyer }
500 1.1 bouyer
501 1.1 bouyer /*
502 1.1 bouyer * Recursively free last partial block.
503 1.1 bouyer */
504 1.1 bouyer if (level > SINGLE && lastbn >= 0) {
505 1.1 bouyer last = lastbn % factor;
506 1.3 bouyer nb = fs2h32(bap[i]);
507 1.1 bouyer if (nb != 0) {
508 1.1 bouyer error = ext2fs_indirtrunc(ip, nlbn, fsbtodb(fs, nb),
509 1.1 bouyer last, level - 1, &blkcount);
510 1.1 bouyer if (error)
511 1.1 bouyer allerror = error;
512 1.1 bouyer blocksreleased += blkcount;
513 1.1 bouyer }
514 1.1 bouyer }
515 1.1 bouyer
516 1.1 bouyer if (copy != NULL) {
517 1.1 bouyer FREE(copy, M_TEMP);
518 1.1 bouyer } else {
519 1.1 bouyer bp->b_flags |= B_INVAL;
520 1.1 bouyer brelse(bp);
521 1.1 bouyer }
522 1.1 bouyer
523 1.1 bouyer *countp = blocksreleased;
524 1.1 bouyer return (allerror);
525 1.1 bouyer }
526