![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to freelists.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Early Linux] / linux / fs / ext|
Return to freelists.c CVS log | Up to [Early Linux] / linux / fs / ext |
1.1 root 1: /*
2: * linux/fs/ext/freelists.c
3: *
4: * (C) 1992 Remy Card ([email protected])
5: *
6: */
7:
8: /* freelists.c contains the code that handles the inode and block free lists */
9:
10:
11: /*
12:
13: The free blocks are managed by a linked list. The super block contains the
14: number of the first free block. This block contains 254 numbers of other
15: free blocks and the number of the next block in the list.
16:
17: When an ext fs is mounted, the number of the first free block is stored
18: in s->s_zmap[0] and the block header is stored in s->s_zmap[1]. s_zmap[2]
19: contains the count of free blocks.
20:
21: Currently, it is a hack to allow this kind of management with the super_block
22: structure.
23: Perhaps, in the future, we may have to change the super_block structure to
24: include dedicated fields.
25:
26: The free inodes are also managed by a linked list in a similar way. The
27: super block contains the number of the first free inode. This inode contains
28: 14 numbers of other free inodes and the number of the next inode in the list.
29:
30: The number of the first free inode is stored in s->s_imap[0] and the header
31: of the block containing the inode is stored in s->s_imap[1]. s_imap[2] contains
32: the count of free inodes.
33:
34: */
35:
36: #include <linux/string.h>
37:
38: #include <linux/sched.h>
39: #include <linux/ext_fs.h>
40: #include <linux/kernel.h>
41:
42: #ifdef EXTFS_FREELIST
43:
44: #define clear_block(addr) \
45: __asm__("cld\n\t" \
46: "rep\n\t" \
47: "stosl" \
48: ::"a" (0),"c" (BLOCK_SIZE/4),"D" ((long) (addr)):"cx","di")
49:
50: int ext_free_block(int dev, int block)
51: {
52: struct super_block * sb;
53: struct buffer_head * bh;
54: struct ext_free_block * efb;
55:
56: if (!(sb = get_super(dev)))
57: panic("trying to free block on nonexistent device");
58: lock_super (sb);
59: if (block < sb->s_firstdatazone || block >= sb->s_nzones)
60: panic("trying to free block not in datazone");
61: bh = get_hash_table(dev,block);
62: if (bh) {
63: if (bh->b_count > 1) {
64: brelse(bh);
65: free_super (sb);
66: return 0;
67: }
68: bh->b_dirt=0;
69: bh->b_uptodate=0;
70: if (bh->b_count)
71: brelse(bh);
72: }
73: efb = (struct ext_free_block *) sb->s_zmap[1]->b_data;
74: if (efb->count == 254) {
75: #ifdef EXTFS_DEBUG
76: printk("ext_free_block: block full, skipping to %d\n", block);
77: #endif
78: brelse (sb->s_zmap[1]);
79: if (!(sb->s_zmap[1] = bread (dev, block)))
80: panic ("ext_free_block: unable to read block to free\n");
81: efb = (struct ext_free_block *) sb->s_zmap[1]->b_data;
82: efb->next = (unsigned long) sb->s_zmap[0];
83: efb->count = 0;
84: sb->s_zmap[0] = (struct buffer_head *) block;
85: } else {
86: efb->free[efb->count++] = block;
87: }
88: sb->s_zmap[2] = (struct buffer_head *) (((unsigned long) sb->s_zmap[2]) + 1);
89: sb->s_dirt = 1;
90: sb->s_zmap[1]->b_dirt = 1;
91: free_super (sb);
92: return 1;
93: }
94:
95: int ext_new_block(int dev)
96: {
97: struct buffer_head * bh;
98: struct super_block * sb;
99: struct ext_free_block * efb;
100: int /* i, */ j;
101:
102: if (!(sb = get_super(dev)))
103: panic("trying to get new block from nonexistant device");
104: if (!sb->s_zmap[1])
105: return 0;
106: lock_super (sb);
107: efb = (struct ext_free_block *) sb->s_zmap[1]->b_data;
108: if (efb->count) {
109: j = efb->free[--efb->count];
110: sb->s_zmap[1]->b_dirt = 1;
111: } else {
112: #ifdef EXTFS_DEBUG
113: printk("ext_new_block: block empty, skipping to %d\n", efb->next);
114: #endif
115: j = (unsigned long) sb->s_zmap[0];
116: sb->s_zmap[0] = (struct buffer_head *) efb->next;
117: brelse (sb->s_zmap[1]);
118: if (!sb->s_zmap[0]) {
119: sb->s_zmap[1] = NULL;
120: } else {
121: if (!(sb->s_zmap[1] = bread (dev, (unsigned long) sb->s_zmap[0])))
122: panic ("ext_new_block: unable to read next free block\n");
123: }
124: }
125: if (j < sb->s_firstdatazone || j > sb->s_nzones) {
126: printk ("ext_new_block: blk = %d\n", j);
127: panic ("allocating block not in data zone\n");
128: }
129: sb->s_zmap[2] = (struct buffer_head *) (((unsigned long) sb->s_zmap[2]) - 1);
130: sb->s_dirt = 1;
131:
132: if (!(bh=getblk(dev,j)))
133: panic("new_block: cannot get block");
134: if (bh->b_count != 1)
135: panic("new block: count is != 1");
136: clear_block(bh->b_data);
137: bh->b_uptodate = 1;
138: bh->b_dirt = 1;
139: brelse(bh);
140: #ifdef EXTFS_DEBUG
141: printk("ext_new_block: allocating block %d\n", j);
142: #endif
143: free_super (sb);
144: return j;
145: }
146:
147: unsigned long ext_count_free_blocks(struct super_block *sb)
148: {
149: #ifdef EXTFS_DEBUG
150: struct buffer_head * bh;
151: struct ext_free_block * efb;
152: unsigned long count, block;
153:
154: lock_super (sb);
155: if (!sb->s_zmap[1])
156: count = 0;
157: else {
158: efb = (struct ext_free_block *) sb->s_zmap[1]->b_data;
159: count = efb->count + 1;
160: block = efb->next;
161: while (block) {
162: if (!(bh = bread (sb->s_dev, block))) {
163: printk ("ext_count_free: error while reading free blocks list\n");
164: block = 0;
165: } else {
166: efb = (struct ext_free_block *) bh->b_data;
167: count += efb->count + 1;
168: block = efb->next;
169: brelse (bh);
170: }
171: }
172: }
173: printk("ext_count_free_blocks: stored = %d, computed = %d\n",
174: (unsigned long) sb->s_zmap[2], count);
175: free_super (sb);
176: return count;
177: #else
178: return (unsigned long) sb->s_zmap[2];
179: #endif
180: }
181:
182: void ext_free_inode(struct inode * inode)
183: {
184: struct buffer_head * bh;
185: struct ext_free_inode * efi;
186: unsigned long block;
187:
188: if (!inode)
189: return;
190: if (!inode->i_dev) {
191: memset(inode,0,sizeof(*inode));
192: return;
193: }
194: if (inode->i_count>1) {
195: printk("free_inode: inode has count=%d\n",inode->i_count);
196: return;
197: }
198: if (inode->i_nlink) {
199: printk("free_inode: inode has nlink=%d\n",inode->i_nlink);
200: return;
201: }
202: if (!inode->i_sb) {
203: printk("free_inode: inode on nonexistent device\n");
204: return;
205: }
206: lock_super (inode->i_sb);
207: if (inode->i_ino < 1 || inode->i_ino > inode->i_sb->s_ninodes) {
208: printk("free_inode: inode 0 or nonexistent inode\n");
209: free_super (inode->i_sb);
210: return;
211: }
212: efi = ((struct ext_free_inode *) inode->i_sb->s_imap[1]->b_data) +
213: (((unsigned long) inode->i_sb->s_imap[0])-1)%EXT_INODES_PER_BLOCK;
214: if (efi->count == 14) {
215: #ifdef EXTFS_DEBUG
216: printk("ext_free_inode: inode full, skipping to %d\n", inode->i_ino);
217: #endif
218: brelse (inode->i_sb->s_imap[1]);
219: block = 2 + (inode->i_ino - 1) / EXT_INODES_PER_BLOCK;
220: if (!(bh = bread(inode->i_dev, block)))
221: panic("ext_free_inode: unable to read inode block\n");
222: efi = ((struct ext_free_inode *) bh->b_data) +
223: (inode->i_ino - 1) % EXT_INODES_PER_BLOCK;
224: efi->next = (unsigned long) inode->i_sb->s_imap[0];
225: efi->count = 0;
226: inode->i_sb->s_imap[0] = (struct buffer_head *) inode->i_ino;
227: inode->i_sb->s_imap[1] = bh;
228: } else {
229: efi->free[efi->count++] = inode->i_ino;
230: }
231: inode->i_sb->s_imap[2] = (struct buffer_head *) (((unsigned long) inode->i_sb->s_imap[2]) + 1);
232: inode->i_sb->s_dirt = 1;
233: inode->i_sb->s_imap[1]->b_dirt = 1;
234: free_super (inode->i_sb);
235: memset(inode,0,sizeof(*inode));
236: }
237:
238: struct inode * ext_new_inode(int dev)
239: {
240: struct inode * inode;
241: struct ext_free_inode * efi;
242: unsigned long block;
243: int /* i, */ j;
244:
245: if (!(inode=get_empty_inode()))
246: return NULL;
247: if (!(inode->i_sb = get_super(dev))) {
248: printk("new_inode: unknown device\n");
249: iput(inode);
250: return NULL;
251: }
252: if (!inode->i_sb->s_imap[1])
253: return 0;
254: lock_super (inode->i_sb);
255: efi = ((struct ext_free_inode *) inode->i_sb->s_imap[1]->b_data) +
256: (((unsigned long) inode->i_sb->s_imap[0])-1)%EXT_INODES_PER_BLOCK;
257: if (efi->count) {
258: j = efi->free[--efi->count];
259: inode->i_sb->s_imap[1]->b_dirt = 1;
260: } else {
261: #ifdef EXTFS_DEBUG
262: printk("ext_free_inode: inode empty, skipping to %d\n", efi->next);
263: #endif
264: j = (unsigned long) inode->i_sb->s_imap[0];
265: if (efi->next < 1 || efi->next > inode->i_sb->s_ninodes) {
266: printk ("efi->next = %d\n", efi->next);
267: panic ("ext_new_inode: bad inode number in free list\n");
268: }
269: inode->i_sb->s_imap[0] = (struct buffer_head *) efi->next;
270: block = 2 + (((unsigned long) efi->next) - 1) / EXT_INODES_PER_BLOCK;
271: brelse (inode->i_sb->s_imap[1]);
272: if (!inode->i_sb->s_imap[0]) {
273: inode->i_sb->s_imap[1] = NULL;
274: } else {
275: if (!(inode->i_sb->s_imap[1] = bread (dev, block)))
276: panic ("ext_new_inode: unable to read next free inode block\n");
277: }
278: }
279: inode->i_sb->s_imap[2] = (struct buffer_head *) (((unsigned long) inode->i_sb->s_imap[2]) - 1);
280: inode->i_sb->s_dirt = 1;
281: inode->i_count = 1;
282: inode->i_nlink = 1;
283: inode->i_dev = dev;
284: inode->i_uid = current->euid;
285: inode->i_gid = current->egid;
286: inode->i_dirt = 1;
287: inode->i_ino = j;
288: inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
289: inode->i_op = NULL;
290: #ifdef EXTFS_DEBUG
291: printk("ext_new_inode : allocating inode %d\n", inode->i_ino);
292: #endif
293: free_super (inode->i_sb);
294: return inode;
295: }
296:
297: unsigned long ext_count_free_inodes(struct super_block *sb)
298: {
299: #ifdef EXTFS_DEBUG
300: struct buffer_head * bh;
301: struct ext_free_inode * efi;
302: unsigned long count, block, ino;
303:
304: lock_super (sb);
305: if (!sb->s_imap[1])
306: count = 0;
307: else {
308: efi = ((struct ext_free_inode *) sb->s_imap[1]->b_data) +
309: ((((unsigned long) sb->s_imap[0])-1)%EXT_INODES_PER_BLOCK);
310: count = efi->count + 1;
311: ino = efi->next;
312: while (ino) {
313: if (ino < 1 || ino > sb->s_ninodes) {
314: printk ("s_imap[0] = %d, ino = %d\n",
315: (int) sb->s_imap[0],ino);
316: panic ("ext_count_fre_inodes: bad inode number in free list\n");
317: }
318: block = 2 + ((ino - 1) / EXT_INODES_PER_BLOCK);
319: if (!(bh = bread (sb->s_dev, block))) {
320: printk ("ext_count_free_inodes: error while reading free inodes list\n");
321: block = 0;
322: } else {
323: efi = ((struct ext_free_inode *) bh->b_data) +
324: ((ino - 1) % EXT_INODES_PER_BLOCK);
325: count += efi->count + 1;
326: ino = efi->next;
327: brelse (bh);
328: }
329: }
330: }
331: printk("ext_count_free_inodes: stored = %d, computed = %d\n",
332: (unsigned long) sb->s_imap[2], count);
333: free_super (sb);
334: return count;
335: #else
336: return (unsigned long) sb->s_imap[2];
337: #endif
338: }
339:
340: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.