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