blob: 4a6abc49418ef9917106d3ed6077be25154e57e4 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/minix/bitmap.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
6
7/*
8 * Modified for 680x0 by Hamish Macdonald
9 * Fixed for 680x0 by Andreas Schwab
10 */
11
12/* bitmap.c contains the code that handles the inode and block bitmaps */
13
14#include "minix.h"
15#include <linux/smp_lock.h>
16#include <linux/buffer_head.h>
17#include <linux/bitops.h>
18
19static int nibblemap[] = { 4,3,3,2,3,2,2,1,3,2,2,1,2,1,1,0 };
20
21static unsigned long count_free(struct buffer_head *map[], unsigned numblocks, __u32 numbits)
22{
23 unsigned i, j, sum = 0;
24 struct buffer_head *bh;
25
26 for (i=0; i<numblocks-1; i++) {
27 if (!(bh=map[i]))
28 return(0);
29 for (j=0; j<BLOCK_SIZE; j++)
30 sum += nibblemap[bh->b_data[j] & 0xf]
31 + nibblemap[(bh->b_data[j]>>4) & 0xf];
32 }
33
34 if (numblocks==0 || !(bh=map[numblocks-1]))
35 return(0);
36 i = ((numbits-(numblocks-1)*BLOCK_SIZE*8)/16)*2;
37 for (j=0; j<i; j++) {
38 sum += nibblemap[bh->b_data[j] & 0xf]
39 + nibblemap[(bh->b_data[j]>>4) & 0xf];
40 }
41
42 i = numbits%16;
43 if (i!=0) {
44 i = *(__u16 *)(&bh->b_data[j]) | ~((1<<i) - 1);
45 sum += nibblemap[i & 0xf] + nibblemap[(i>>4) & 0xf];
46 sum += nibblemap[(i>>8) & 0xf] + nibblemap[(i>>12) & 0xf];
47 }
48 return(sum);
49}
50
51void minix_free_block(struct inode * inode, int block)
52{
53 struct super_block * sb = inode->i_sb;
54 struct minix_sb_info * sbi = minix_sb(sb);
55 struct buffer_head * bh;
56 unsigned int bit,zone;
57
58 if (block < sbi->s_firstdatazone || block >= sbi->s_nzones) {
Denis Vlasenko11b84482006-03-25 03:07:42 -080059 printk("Trying to free block not in datazone\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 return;
61 }
62 zone = block - sbi->s_firstdatazone + 1;
63 bit = zone & 8191;
64 zone >>= 13;
65 if (zone >= sbi->s_zmap_blocks) {
66 printk("minix_free_block: nonexistent bitmap buffer\n");
67 return;
68 }
69 bh = sbi->s_zmap[zone];
70 lock_kernel();
71 if (!minix_test_and_clear_bit(bit,bh->b_data))
72 printk("free_block (%s:%d): bit already cleared\n",
73 sb->s_id, block);
74 unlock_kernel();
75 mark_buffer_dirty(bh);
76 return;
77}
78
79int minix_new_block(struct inode * inode)
80{
81 struct minix_sb_info *sbi = minix_sb(inode->i_sb);
82 int i;
83
84 for (i = 0; i < sbi->s_zmap_blocks; i++) {
85 struct buffer_head *bh = sbi->s_zmap[i];
86 int j;
87
88 lock_kernel();
89 if ((j = minix_find_first_zero_bit(bh->b_data, 8192)) < 8192) {
90 minix_set_bit(j,bh->b_data);
91 unlock_kernel();
92 mark_buffer_dirty(bh);
93 j += i*8192 + sbi->s_firstdatazone-1;
94 if (j < sbi->s_firstdatazone || j >= sbi->s_nzones)
95 break;
96 return j;
97 }
98 unlock_kernel();
99 }
100 return 0;
101}
102
103unsigned long minix_count_free_blocks(struct minix_sb_info *sbi)
104{
105 return (count_free(sbi->s_zmap, sbi->s_zmap_blocks,
106 sbi->s_nzones - sbi->s_firstdatazone + 1)
107 << sbi->s_log_zone_size);
108}
109
110struct minix_inode *
111minix_V1_raw_inode(struct super_block *sb, ino_t ino, struct buffer_head **bh)
112{
113 int block;
114 struct minix_sb_info *sbi = minix_sb(sb);
115 struct minix_inode *p;
116
117 if (!ino || ino > sbi->s_ninodes) {
118 printk("Bad inode number on dev %s: %ld is out of range\n",
119 sb->s_id, (long)ino);
120 return NULL;
121 }
122 ino--;
123 block = 2 + sbi->s_imap_blocks + sbi->s_zmap_blocks +
124 ino / MINIX_INODES_PER_BLOCK;
125 *bh = sb_bread(sb, block);
126 if (!*bh) {
Denis Vlasenko11b84482006-03-25 03:07:42 -0800127 printk("Unable to read inode block\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 return NULL;
129 }
130 p = (void *)(*bh)->b_data;
131 return p + ino % MINIX_INODES_PER_BLOCK;
132}
133
134struct minix2_inode *
135minix_V2_raw_inode(struct super_block *sb, ino_t ino, struct buffer_head **bh)
136{
137 int block;
138 struct minix_sb_info *sbi = minix_sb(sb);
139 struct minix2_inode *p;
140
141 *bh = NULL;
142 if (!ino || ino > sbi->s_ninodes) {
143 printk("Bad inode number on dev %s: %ld is out of range\n",
144 sb->s_id, (long)ino);
145 return NULL;
146 }
147 ino--;
148 block = 2 + sbi->s_imap_blocks + sbi->s_zmap_blocks +
149 ino / MINIX2_INODES_PER_BLOCK;
150 *bh = sb_bread(sb, block);
151 if (!*bh) {
Denis Vlasenko11b84482006-03-25 03:07:42 -0800152 printk("Unable to read inode block\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 return NULL;
154 }
155 p = (void *)(*bh)->b_data;
156 return p + ino % MINIX2_INODES_PER_BLOCK;
157}
158
159/* Clear the link count and mode of a deleted inode on disk. */
160
161static void minix_clear_inode(struct inode *inode)
162{
163 struct buffer_head *bh = NULL;
164
165 if (INODE_VERSION(inode) == MINIX_V1) {
166 struct minix_inode *raw_inode;
167 raw_inode = minix_V1_raw_inode(inode->i_sb, inode->i_ino, &bh);
168 if (raw_inode) {
169 raw_inode->i_nlinks = 0;
170 raw_inode->i_mode = 0;
171 }
172 } else {
173 struct minix2_inode *raw_inode;
174 raw_inode = minix_V2_raw_inode(inode->i_sb, inode->i_ino, &bh);
175 if (raw_inode) {
176 raw_inode->i_nlinks = 0;
177 raw_inode->i_mode = 0;
178 }
179 }
180 if (bh) {
181 mark_buffer_dirty(bh);
182 brelse (bh);
183 }
184}
185
186void minix_free_inode(struct inode * inode)
187{
188 struct minix_sb_info *sbi = minix_sb(inode->i_sb);
189 struct buffer_head * bh;
190 unsigned long ino;
191
192 ino = inode->i_ino;
193 if (ino < 1 || ino > sbi->s_ninodes) {
194 printk("minix_free_inode: inode 0 or nonexistent inode\n");
195 goto out;
196 }
197 if ((ino >> 13) >= sbi->s_imap_blocks) {
198 printk("minix_free_inode: nonexistent imap in superblock\n");
199 goto out;
200 }
201
202 minix_clear_inode(inode); /* clear on-disk copy */
203
204 bh = sbi->s_imap[ino >> 13];
205 lock_kernel();
206 if (!minix_test_and_clear_bit(ino & 8191, bh->b_data))
Denis Vlasenko11b84482006-03-25 03:07:42 -0800207 printk("minix_free_inode: bit %lu already cleared\n", ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 unlock_kernel();
209 mark_buffer_dirty(bh);
210 out:
211 clear_inode(inode); /* clear in-memory copy */
212}
213
214struct inode * minix_new_inode(const struct inode * dir, int * error)
215{
216 struct super_block *sb = dir->i_sb;
217 struct minix_sb_info *sbi = minix_sb(sb);
218 struct inode *inode = new_inode(sb);
219 struct buffer_head * bh;
220 int i,j;
221
222 if (!inode) {
223 *error = -ENOMEM;
224 return NULL;
225 }
226 j = 8192;
227 bh = NULL;
228 *error = -ENOSPC;
229 lock_kernel();
230 for (i = 0; i < sbi->s_imap_blocks; i++) {
231 bh = sbi->s_imap[i];
232 if ((j = minix_find_first_zero_bit(bh->b_data, 8192)) < 8192)
233 break;
234 }
235 if (!bh || j >= 8192) {
236 unlock_kernel();
237 iput(inode);
238 return NULL;
239 }
240 if (minix_test_and_set_bit(j,bh->b_data)) { /* shouldn't happen */
Denis Vlasenko11b84482006-03-25 03:07:42 -0800241 printk("new_inode: bit already set\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 unlock_kernel();
243 iput(inode);
244 return NULL;
245 }
246 unlock_kernel();
247 mark_buffer_dirty(bh);
248 j += i*8192;
249 if (!j || j > sbi->s_ninodes) {
250 iput(inode);
251 return NULL;
252 }
253 inode->i_uid = current->fsuid;
254 inode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
255 inode->i_ino = j;
256 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
257 inode->i_blocks = inode->i_blksize = 0;
258 memset(&minix_i(inode)->u, 0, sizeof(minix_i(inode)->u));
259 insert_inode_hash(inode);
260 mark_inode_dirty(inode);
261
262 *error = 0;
263 return inode;
264}
265
266unsigned long minix_count_free_inodes(struct minix_sb_info *sbi)
267{
268 return count_free(sbi->s_imap, sbi->s_imap_blocks, sbi->s_ninodes + 1);
269}