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