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