![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ufs_inode.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_inode.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_inode.c 7.34 (Berkeley) 7/3/90
21: */
22:
23: #include "param.h"
24: #include "systm.h"
25: #include "mount.h"
26: #include "user.h"
27: #include "proc.h"
28: #include "file.h"
29: #include "buf.h"
30: #include "cmap.h"
31: #include "vnode.h"
32: #include "../ufs/quota.h"
33: #include "../ufs/inode.h"
34: #include "../ufs/fs.h"
35: #include "../ufs/ufsmount.h"
36: #include "kernel.h"
37: #include "malloc.h"
38:
39: #define INOHSZ 512
40: #if ((INOHSZ&(INOHSZ-1)) == 0)
41: #define INOHASH(dev,ino) (((dev)+(ino))&(INOHSZ-1))
42: #else
43: #define INOHASH(dev,ino) (((unsigned)((dev)+(ino)))%INOHSZ)
44: #endif
45:
46: union ihead {
47: union ihead *ih_head[2];
48: struct inode *ih_chain[2];
49: } ihead[INOHSZ];
50:
51: int prtactive; /* 1 => print out reclaim of active vnodes */
52:
53: /*
54: * Initialize hash links for inodes.
55: */
56: ufs_init()
57: {
58: register int i;
59: register union ihead *ih = ihead;
60:
61: #ifndef lint
62: if (VN_MAXPRIVATE < sizeof(struct inode))
63: panic("ihinit: too small");
64: #endif /* not lint */
65: for (i = INOHSZ; --i >= 0; ih++) {
66: ih->ih_head[0] = ih;
67: ih->ih_head[1] = ih;
68: }
69: #ifdef QUOTA
70: dqinit();
71: #endif /* QUOTA */
72: }
73:
74: /*
75: * Look up an vnode/inode by device,inumber.
76: * If it is in core (in the inode structure),
77: * honor the locking protocol.
78: * If it is not in core, read it in from the
79: * specified device.
80: * Callers must check for mount points!!
81: * In all cases, a pointer to a locked
82: * inode structure is returned.
83: */
84: iget(xp, ino, ipp)
85: struct inode *xp;
86: ino_t ino;
87: struct inode **ipp;
88: {
89: dev_t dev = xp->i_dev;
90: struct mount *mntp = ITOV(xp)->v_mount;
91: register struct fs *fs = VFSTOUFS(mntp)->um_fs;
92: extern struct vnodeops ufs_vnodeops, spec_inodeops;
93: register struct inode *ip, *iq;
94: register struct vnode *vp;
95: struct vnode *nvp;
96: struct buf *bp;
97: struct dinode *dp;
98: union ihead *ih;
99: int i, error;
100:
101: ih = &ihead[INOHASH(dev, ino)];
102: loop:
103: for (ip = ih->ih_chain[0]; ip != (struct inode *)ih; ip = ip->i_forw) {
104: if (ino != ip->i_number || dev != ip->i_dev)
105: continue;
106: if ((ip->i_flag&ILOCKED) != 0) {
107: ip->i_flag |= IWANT;
108: sleep((caddr_t)ip, PINOD);
109: goto loop;
110: }
111: if (vget(ITOV(ip)))
112: goto loop;
113: *ipp = ip;
114: return(0);
115: }
116: /*
117: * Allocate a new inode.
118: */
119: if (error = getnewvnode(VT_UFS, mntp, &ufs_vnodeops, &nvp)) {
120: *ipp = 0;
121: return (error);
122: }
123: ip = VTOI(nvp);
124: ip->i_vnode = nvp;
125: ip->i_flag = 0;
126: ip->i_devvp = 0;
127: ip->i_mode = 0;
128: ip->i_diroff = 0;
129: #ifdef QUOTA
130: for (i = 0; i < MAXQUOTAS; i++)
131: ip->i_dquot[i] = NODQUOT;
132: #endif
133: /*
134: * Put it onto its hash chain and lock it so that other requests for
135: * this inode will block if they arrive while we are sleeping waiting
136: * for old data structures to be purged or for the contents of the
137: * disk portion of this inode to be read.
138: */
139: ip->i_dev = dev;
140: ip->i_number = ino;
141: insque(ip, ih);
142: ILOCK(ip);
143: /*
144: * Read in the disk contents for the inode.
145: */
146: if (error = bread(VFSTOUFS(mntp)->um_devvp, fsbtodb(fs, itod(fs, ino)),
147: (int)fs->fs_bsize, NOCRED, &bp)) {
148: /*
149: * The inode does not contain anything useful, so it would
150: * be misleading to leave it on its hash chain.
151: * Iput() will take care of putting it back on the free list.
152: */
153: remque(ip);
154: ip->i_forw = ip;
155: ip->i_back = ip;
156: /*
157: * Unlock and discard unneeded inode.
158: */
159: iput(ip);
160: brelse(bp);
161: *ipp = 0;
162: return (error);
163: }
164: dp = bp->b_un.b_dino;
165: dp += itoo(fs, ino);
166: ip->i_din = *dp;
167: brelse(bp);
168: /*
169: * Initialize the associated vnode
170: */
171: vp = ITOV(ip);
172: vp->v_type = IFTOVT(ip->i_mode);
173: if (vp->v_type == VFIFO) {
174: #ifdef FIFO
175: extern struct vnodeops fifo_inodeops;
176: vp->v_op = &fifo_inodeops;
177: #else
178: iput(ip);
179: *ipp = 0;
180: return (EOPNOTSUPP);
181: #endif /* FIFO */
182: }
183: if (vp->v_type == VCHR || vp->v_type == VBLK) {
184: vp->v_op = &spec_inodeops;
185: if (nvp = checkalias(vp, ip->i_rdev, mntp)) {
186: /*
187: * Reinitialize aliased inode.
188: */
189: vp = nvp;
190: iq = VTOI(vp);
191: iq->i_vnode = vp;
192: iq->i_flag = 0;
193: ILOCK(iq);
194: iq->i_din = ip->i_din;
195: iq->i_dev = dev;
196: iq->i_number = ino;
197: insque(iq, ih);
198: /*
199: * Discard unneeded vnode
200: */
201: ip->i_mode = 0;
202: iput(ip);
203: ip = iq;
204: }
205: }
206: if (ino == ROOTINO)
207: vp->v_flag |= VROOT;
208: /*
209: * Finish inode initialization.
210: */
211: ip->i_fs = fs;
212: ip->i_devvp = VFSTOUFS(mntp)->um_devvp;
213: VREF(ip->i_devvp);
214: /*
215: * Set up a generation number for this inode if it does not
216: * already have one. This should only happen on old filesystems.
217: */
218: if (ip->i_gen == 0) {
219: if (++nextgennumber < (u_long)time.tv_sec)
220: nextgennumber = time.tv_sec;
221: ip->i_gen = nextgennumber;
222: if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0)
223: ip->i_flag |= IMOD;
224: }
225: *ipp = ip;
226: return (0);
227: }
228:
229: /*
230: * Unlock and decrement the reference count of an inode structure.
231: */
232: iput(ip)
233: register struct inode *ip;
234: {
235:
236: if ((ip->i_flag & ILOCKED) == 0)
237: panic("iput");
238: IUNLOCK(ip);
239: vrele(ITOV(ip));
240: }
241:
242: /*
243: * Last reference to an inode, write the inode out and if necessary,
244: * truncate and deallocate the file.
245: */
246: ufs_inactive(vp)
247: struct vnode *vp;
248: {
249: register struct inode *ip = VTOI(vp);
250: int mode, error = 0;
251:
252: if (prtactive && vp->v_usecount != 0)
253: vprint("ufs_inactive: pushing active", vp);
254: /*
255: * Get rid of inodes related to stale file handles.
256: */
257: if (ip->i_mode == 0) {
258: if ((vp->v_flag & VXLOCK) == 0)
259: vgone(vp);
260: return (0);
261: }
262: ILOCK(ip);
263: if (ip->i_nlink <= 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
264: #ifdef QUOTA
265: if (!getinoquota(ip))
266: (void) chkiq(ip, -1, NOCRED, 0);
267: #endif
268: error = itrunc(ip, (u_long)0, 0);
269: mode = ip->i_mode;
270: ip->i_mode = 0;
271: ip->i_rdev = 0;
272: ip->i_flag |= IUPD|ICHG;
273: ifree(ip, ip->i_number, mode);
274: }
275: IUPDAT(ip, &time, &time, 0);
276: IUNLOCK(ip);
277: ip->i_flag = 0;
278: /*
279: * If we are done with the inode, reclaim it
280: * so that it can be reused immediately.
281: */
282: if (vp->v_usecount == 0 && ip->i_mode == 0)
283: vgone(vp);
284: return (error);
285: }
286:
287: /*
288: * Reclaim an inode so that it can be used for other purposes.
289: */
290: ufs_reclaim(vp)
291: register struct vnode *vp;
292: {
293: register struct inode *ip = VTOI(vp);
294: int i;
295:
296: if (prtactive && vp->v_usecount != 0)
297: vprint("ufs_reclaim: pushing active", vp);
298: /*
299: * Remove the inode from its hash chain.
300: */
301: remque(ip);
302: ip->i_forw = ip;
303: ip->i_back = ip;
304: /*
305: * Purge old data structures associated with the inode.
306: */
307: cache_purge(vp);
308: if (ip->i_devvp) {
309: vrele(ip->i_devvp);
310: ip->i_devvp = 0;
311: }
312: #ifdef QUOTA
313: for (i = 0; i < MAXQUOTAS; i++) {
314: if (ip->i_dquot[i] != NODQUOT) {
315: dqrele(vp, ip->i_dquot[i]);
316: ip->i_dquot[i] = NODQUOT;
317: }
318: }
319: #endif
320: ip->i_flag = 0;
321: return (0);
322: }
323:
324: /*
325: * Check accessed and update flags on an inode structure.
326: * If any is on, update the inode with the current time.
327: * If waitfor is given, then must ensure I/O order,
328: * so wait for write to complete.
329: */
330: iupdat(ip, ta, tm, waitfor)
331: register struct inode *ip;
332: struct timeval *ta, *tm;
333: int waitfor;
334: {
335: struct buf *bp;
336: struct vnode *vp = ITOV(ip);
337: struct dinode *dp;
338: register struct fs *fs;
339: int error;
340:
341: fs = ip->i_fs;
342: if ((ip->i_flag & (IUPD|IACC|ICHG|IMOD)) == 0)
343: return (0);
344: if (vp->v_mount->mnt_flag & MNT_RDONLY)
345: return (0);
346: error = bread(ip->i_devvp, fsbtodb(fs, itod(fs, ip->i_number)),
347: (int)fs->fs_bsize, NOCRED, &bp);
348: if (error) {
349: brelse(bp);
350: return (error);
351: }
352: if (ip->i_flag&IACC)
353: ip->i_atime = ta->tv_sec;
354: if (ip->i_flag&IUPD)
355: ip->i_mtime = tm->tv_sec;
356: if (ip->i_flag&ICHG)
357: ip->i_ctime = time.tv_sec;
358: ip->i_flag &= ~(IUPD|IACC|ICHG|IMOD);
359: dp = bp->b_un.b_dino + itoo(fs, ip->i_number);
360: *dp = ip->i_din;
361: if (waitfor) {
362: return (bwrite(bp));
363: } else {
364: bdwrite(bp);
365: return (0);
366: }
367: }
368:
369: #define SINGLE 0 /* index of single indirect block */
370: #define DOUBLE 1 /* index of double indirect block */
371: #define TRIPLE 2 /* index of triple indirect block */
372: /*
373: * Truncate the inode ip to at most length size. Free affected disk
374: * blocks -- the blocks of the file are removed in reverse order.
375: *
376: * NB: triple indirect blocks are untested.
377: */
378: itrunc(oip, length, flags)
379: register struct inode *oip;
380: u_long length;
381: int flags;
382: {
383: register daddr_t lastblock;
384: daddr_t bn, lbn, lastiblock[NIADDR];
385: register struct fs *fs;
386: register struct inode *ip;
387: struct buf *bp;
388: int offset, osize, size, level;
389: long count, nblocks, blocksreleased = 0;
390: register int i;
391: int aflags, error, allerror;
392: struct inode tip;
393:
394: if (oip->i_size <= length) {
395: oip->i_flag |= ICHG|IUPD;
396: error = iupdat(oip, &time, &time, 1);
397: return (error);
398: }
399: /*
400: * Calculate index into inode's block list of
401: * last direct and indirect blocks (if any)
402: * which we want to keep. Lastblock is -1 when
403: * the file is truncated to 0.
404: */
405: fs = oip->i_fs;
406: lastblock = lblkno(fs, length + fs->fs_bsize - 1) - 1;
407: lastiblock[SINGLE] = lastblock - NDADDR;
408: lastiblock[DOUBLE] = lastiblock[SINGLE] - NINDIR(fs);
409: lastiblock[TRIPLE] = lastiblock[DOUBLE] - NINDIR(fs) * NINDIR(fs);
410: nblocks = btodb(fs->fs_bsize);
411: /*
412: * Update the size of the file. If the file is not being
413: * truncated to a block boundry, the contents of the
414: * partial block following the end of the file must be
415: * zero'ed in case it ever become accessable again because
416: * of subsequent file growth.
417: */
418: osize = oip->i_size;
419: offset = blkoff(fs, length);
420: if (offset == 0) {
421: oip->i_size = length;
422: } else {
423: lbn = lblkno(fs, length);
424: aflags = B_CLRBUF;
425: if (flags & IO_SYNC)
426: aflags |= B_SYNC;
427: #ifdef QUOTA
428: if (error = getinoquota(oip))
429: return (error);
430: #endif
431: if (error = balloc(oip, lbn, offset, &bp, aflags))
432: return (error);
433: oip->i_size = length;
434: size = blksize(fs, oip, lbn);
435: bn = bp->b_blkno;
436: count = howmany(size, CLBYTES);
437: for (i = 0; i < count; i++)
438: munhash(oip->i_devvp, bn + i * CLBYTES / DEV_BSIZE);
439: bzero(bp->b_un.b_addr + offset, (unsigned)(size - offset));
440: brealloc(bp, size);
441: if (flags & IO_SYNC)
442: bwrite(bp);
443: else
444: bdwrite(bp);
445: }
446: /*
447: * Update file and block pointers
448: * on disk before we start freeing blocks.
449: * If we crash before free'ing blocks below,
450: * the blocks will be returned to the free list.
451: * lastiblock values are also normalized to -1
452: * for calls to indirtrunc below.
453: */
454: tip = *oip;
455: tip.i_size = osize;
456: for (level = TRIPLE; level >= SINGLE; level--)
457: if (lastiblock[level] < 0) {
458: oip->i_ib[level] = 0;
459: lastiblock[level] = -1;
460: }
461: for (i = NDADDR - 1; i > lastblock; i--)
462: oip->i_db[i] = 0;
463: oip->i_flag |= ICHG|IUPD;
464: vinvalbuf(ITOV(oip), (length > 0));
465: allerror = iupdat(oip, &time, &time, MNT_WAIT);
466:
467: /*
468: * Indirect blocks first.
469: */
470: ip = &tip;
471: for (level = TRIPLE; level >= SINGLE; level--) {
472: bn = ip->i_ib[level];
473: if (bn != 0) {
474: error = indirtrunc(ip, bn, lastiblock[level], level,
475: &count);
476: if (error)
477: allerror = error;
478: blocksreleased += count;
479: if (lastiblock[level] < 0) {
480: ip->i_ib[level] = 0;
481: blkfree(ip, bn, (off_t)fs->fs_bsize);
482: blocksreleased += nblocks;
483: }
484: }
485: if (lastiblock[level] >= 0)
486: goto done;
487: }
488:
489: /*
490: * All whole direct blocks or frags.
491: */
492: for (i = NDADDR - 1; i > lastblock; i--) {
493: register off_t bsize;
494:
495: bn = ip->i_db[i];
496: if (bn == 0)
497: continue;
498: ip->i_db[i] = 0;
499: bsize = (off_t)blksize(fs, ip, i);
500: blkfree(ip, bn, bsize);
501: blocksreleased += btodb(bsize);
502: }
503: if (lastblock < 0)
504: goto done;
505:
506: /*
507: * Finally, look for a change in size of the
508: * last direct block; release any frags.
509: */
510: bn = ip->i_db[lastblock];
511: if (bn != 0) {
512: off_t oldspace, newspace;
513:
514: /*
515: * Calculate amount of space we're giving
516: * back as old block size minus new block size.
517: */
518: oldspace = blksize(fs, ip, lastblock);
519: ip->i_size = length;
520: newspace = blksize(fs, ip, lastblock);
521: if (newspace == 0)
522: panic("itrunc: newspace");
523: if (oldspace - newspace > 0) {
524: /*
525: * Block number of space to be free'd is
526: * the old block # plus the number of frags
527: * required for the storage we're keeping.
528: */
529: bn += numfrags(fs, newspace);
530: blkfree(ip, bn, oldspace - newspace);
531: blocksreleased += btodb(oldspace - newspace);
532: }
533: }
534: done:
535: /* BEGIN PARANOIA */
536: for (level = SINGLE; level <= TRIPLE; level++)
537: if (ip->i_ib[level] != oip->i_ib[level])
538: panic("itrunc1");
539: for (i = 0; i < NDADDR; i++)
540: if (ip->i_db[i] != oip->i_db[i])
541: panic("itrunc2");
542: /* END PARANOIA */
543: oip->i_blocks -= blocksreleased;
544: if (oip->i_blocks < 0) /* sanity */
545: oip->i_blocks = 0;
546: oip->i_flag |= ICHG;
547: #ifdef QUOTA
548: if (!getinoquota(oip))
549: (void) chkdq(oip, -blocksreleased, NOCRED, 0);
550: #endif
551: return (allerror);
552: }
553:
554: /*
555: * Release blocks associated with the inode ip and
556: * stored in the indirect block bn. Blocks are free'd
557: * in LIFO order up to (but not including) lastbn. If
558: * level is greater than SINGLE, the block is an indirect
559: * block and recursive calls to indirtrunc must be used to
560: * cleanse other indirect blocks.
561: *
562: * NB: triple indirect blocks are untested.
563: */
564: indirtrunc(ip, bn, lastbn, level, countp)
565: register struct inode *ip;
566: daddr_t bn, lastbn;
567: int level;
568: long *countp;
569: {
570: register int i;
571: struct buf *bp;
572: register struct fs *fs = ip->i_fs;
573: register daddr_t *bap;
574: daddr_t *copy, nb, last;
575: long blkcount, factor;
576: int nblocks, blocksreleased = 0;
577: int error, allerror = 0;
578:
579: /*
580: * Calculate index in current block of last
581: * block to be kept. -1 indicates the entire
582: * block so we need not calculate the index.
583: */
584: factor = 1;
585: for (i = SINGLE; i < level; i++)
586: factor *= NINDIR(fs);
587: last = lastbn;
588: if (lastbn > 0)
589: last /= factor;
590: nblocks = btodb(fs->fs_bsize);
591: /*
592: * Get buffer of block pointers, zero those
593: * entries corresponding to blocks to be free'd,
594: * and update on disk copy first.
595: */
596: error = bread(ip->i_devvp, fsbtodb(fs, bn), (int)fs->fs_bsize,
597: NOCRED, &bp);
598: if (error) {
599: brelse(bp);
600: *countp = 0;
601: return (error);
602: }
603: bap = bp->b_un.b_daddr;
604: MALLOC(copy, daddr_t *, fs->fs_bsize, M_TEMP, M_WAITOK);
605: bcopy((caddr_t)bap, (caddr_t)copy, (u_int)fs->fs_bsize);
606: bzero((caddr_t)&bap[last + 1],
607: (u_int)(NINDIR(fs) - (last + 1)) * sizeof (daddr_t));
608: if (last == -1)
609: bp->b_flags |= B_INVAL;
610: error = bwrite(bp);
611: if (error)
612: allerror = error;
613: bap = copy;
614:
615: /*
616: * Recursively free totally unused blocks.
617: */
618: for (i = NINDIR(fs) - 1; i > last; i--) {
619: nb = bap[i];
620: if (nb == 0)
621: continue;
622: if (level > SINGLE) {
623: error = indirtrunc(ip, nb, (daddr_t)-1, level - 1,
624: &blkcount);
625: if (error)
626: allerror = error;
627: blocksreleased += blkcount;
628: }
629: blkfree(ip, nb, (off_t)fs->fs_bsize);
630: blocksreleased += nblocks;
631: }
632:
633: /*
634: * Recursively free last partial block.
635: */
636: if (level > SINGLE && lastbn >= 0) {
637: last = lastbn % factor;
638: nb = bap[i];
639: if (nb != 0) {
640: error = indirtrunc(ip, nb, last, level - 1, &blkcount);
641: if (error)
642: allerror = error;
643: blocksreleased += blkcount;
644: }
645: }
646: FREE(copy, M_TEMP);
647: *countp = blocksreleased;
648: return (allerror);
649: }
650:
651: /*
652: * Lock an inode. If its already locked, set the WANT bit and sleep.
653: */
654: ilock(ip)
655: register struct inode *ip;
656: {
657:
658: while (ip->i_flag & ILOCKED) {
659: ip->i_flag |= IWANT;
660: if (ip->i_spare0 == u.u_procp->p_pid)
661: panic("locking against myself");
662: ip->i_spare1 = u.u_procp->p_pid;
663: (void) sleep((caddr_t)ip, PINOD);
664: }
665: ip->i_spare1 = 0;
666: ip->i_spare0 = u.u_procp->p_pid;
667: u.u_spare[0]++;
668: ip->i_flag |= ILOCKED;
669: }
670:
671: /*
672: * Unlock an inode. If WANT bit is on, wakeup.
673: */
674: iunlock(ip)
675: register struct inode *ip;
676: {
677:
678: if ((ip->i_flag & ILOCKED) == 0)
679: vprint("iunlock: unlocked inode", ITOV(ip));
680: ip->i_spare0 = 0;
681: u.u_spare[0]--;
682: ip->i_flag &= ~ILOCKED;
683: if (ip->i_flag&IWANT) {
684: ip->i_flag &= ~IWANT;
685: wakeup((caddr_t)ip);
686: }
687: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.