xref: /openbmc/linux/fs/minix/bitmap.c (revision e868d61272caa648214046a096e5a6bfc068dc8c)
1 /*
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 
19 static int nibblemap[] = { 4,3,3,2,3,2,2,1,3,2,2,1,2,1,1,0 };
20 
21 static 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<bh->b_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) * bh->b_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 
51 void minix_free_block(struct inode *inode, unsigned long 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 	int k = sb->s_blocksize_bits + 3;
57 	unsigned long bit, zone;
58 
59 	if (block < sbi->s_firstdatazone || block >= sbi->s_nzones) {
60 		printk("Trying to free block not in datazone\n");
61 		return;
62 	}
63 	zone = block - sbi->s_firstdatazone + 1;
64 	bit = zone & ((1<<k) - 1);
65 	zone >>= k;
66 	if (zone >= sbi->s_zmap_blocks) {
67 		printk("minix_free_block: nonexistent bitmap buffer\n");
68 		return;
69 	}
70 	bh = sbi->s_zmap[zone];
71 	lock_kernel();
72 	if (!minix_test_and_clear_bit(bit, bh->b_data))
73 		printk("minix_free_block (%s:%lu): bit already cleared\n",
74 		       sb->s_id, block);
75 	unlock_kernel();
76 	mark_buffer_dirty(bh);
77 	return;
78 }
79 
80 int minix_new_block(struct inode * inode)
81 {
82 	struct minix_sb_info *sbi = minix_sb(inode->i_sb);
83 	int bits_per_zone = 8 * inode->i_sb->s_blocksize;
84 	int i;
85 
86 	for (i = 0; i < sbi->s_zmap_blocks; i++) {
87 		struct buffer_head *bh = sbi->s_zmap[i];
88 		int j;
89 
90 		lock_kernel();
91 		j = minix_find_first_zero_bit(bh->b_data, bits_per_zone);
92 		if (j < bits_per_zone) {
93 			minix_set_bit(j, bh->b_data);
94 			unlock_kernel();
95 			mark_buffer_dirty(bh);
96 			j += i * bits_per_zone + sbi->s_firstdatazone-1;
97 			if (j < sbi->s_firstdatazone || j >= sbi->s_nzones)
98 				break;
99 			return j;
100 		}
101 		unlock_kernel();
102 	}
103 	return 0;
104 }
105 
106 unsigned long minix_count_free_blocks(struct minix_sb_info *sbi)
107 {
108 	return (count_free(sbi->s_zmap, sbi->s_zmap_blocks,
109 		sbi->s_nzones - sbi->s_firstdatazone + 1)
110 		<< sbi->s_log_zone_size);
111 }
112 
113 struct minix_inode *
114 minix_V1_raw_inode(struct super_block *sb, ino_t ino, struct buffer_head **bh)
115 {
116 	int block;
117 	struct minix_sb_info *sbi = minix_sb(sb);
118 	struct minix_inode *p;
119 
120 	if (!ino || ino > sbi->s_ninodes) {
121 		printk("Bad inode number on dev %s: %ld is out of range\n",
122 		       sb->s_id, (long)ino);
123 		return NULL;
124 	}
125 	ino--;
126 	block = 2 + sbi->s_imap_blocks + sbi->s_zmap_blocks +
127 		 ino / MINIX_INODES_PER_BLOCK;
128 	*bh = sb_bread(sb, block);
129 	if (!*bh) {
130 		printk("Unable to read inode block\n");
131 		return NULL;
132 	}
133 	p = (void *)(*bh)->b_data;
134 	return p + ino % MINIX_INODES_PER_BLOCK;
135 }
136 
137 struct minix2_inode *
138 minix_V2_raw_inode(struct super_block *sb, ino_t ino, struct buffer_head **bh)
139 {
140 	int block;
141 	struct minix_sb_info *sbi = minix_sb(sb);
142 	struct minix2_inode *p;
143 	int minix2_inodes_per_block = sb->s_blocksize / sizeof(struct minix2_inode);
144 
145 	*bh = NULL;
146 	if (!ino || ino > sbi->s_ninodes) {
147 		printk("Bad inode number on dev %s: %ld is out of range\n",
148 		       sb->s_id, (long)ino);
149 		return NULL;
150 	}
151 	ino--;
152 	block = 2 + sbi->s_imap_blocks + sbi->s_zmap_blocks +
153 		 ino / minix2_inodes_per_block;
154 	*bh = sb_bread(sb, block);
155 	if (!*bh) {
156 		printk("Unable to read inode block\n");
157 		return NULL;
158 	}
159 	p = (void *)(*bh)->b_data;
160 	return p + ino % minix2_inodes_per_block;
161 }
162 
163 /* Clear the link count and mode of a deleted inode on disk. */
164 
165 static void minix_clear_inode(struct inode *inode)
166 {
167 	struct buffer_head *bh = NULL;
168 
169 	if (INODE_VERSION(inode) == MINIX_V1) {
170 		struct minix_inode *raw_inode;
171 		raw_inode = minix_V1_raw_inode(inode->i_sb, inode->i_ino, &bh);
172 		if (raw_inode) {
173 			raw_inode->i_nlinks = 0;
174 			raw_inode->i_mode = 0;
175 		}
176 	} else {
177 		struct minix2_inode *raw_inode;
178 		raw_inode = minix_V2_raw_inode(inode->i_sb, inode->i_ino, &bh);
179 		if (raw_inode) {
180 			raw_inode->i_nlinks = 0;
181 			raw_inode->i_mode = 0;
182 		}
183 	}
184 	if (bh) {
185 		mark_buffer_dirty(bh);
186 		brelse (bh);
187 	}
188 }
189 
190 void minix_free_inode(struct inode * inode)
191 {
192 	struct super_block *sb = inode->i_sb;
193 	struct minix_sb_info *sbi = minix_sb(inode->i_sb);
194 	struct buffer_head *bh;
195 	int k = sb->s_blocksize_bits + 3;
196 	unsigned long ino, bit;
197 
198 	ino = inode->i_ino;
199 	if (ino < 1 || ino > sbi->s_ninodes) {
200 		printk("minix_free_inode: inode 0 or nonexistent inode\n");
201 		goto out;
202 	}
203 	bit = ino & ((1<<k) - 1);
204 	ino >>= k;
205 	if (ino >= sbi->s_imap_blocks) {
206 		printk("minix_free_inode: nonexistent imap in superblock\n");
207 		goto out;
208 	}
209 
210 	minix_clear_inode(inode);	/* clear on-disk copy */
211 
212 	bh = sbi->s_imap[ino];
213 	lock_kernel();
214 	if (!minix_test_and_clear_bit(bit, bh->b_data))
215 		printk("minix_free_inode: bit %lu already cleared\n", bit);
216 	unlock_kernel();
217 	mark_buffer_dirty(bh);
218  out:
219 	clear_inode(inode);		/* clear in-memory copy */
220 }
221 
222 struct inode * minix_new_inode(const struct inode * dir, int * error)
223 {
224 	struct super_block *sb = dir->i_sb;
225 	struct minix_sb_info *sbi = minix_sb(sb);
226 	struct inode *inode = new_inode(sb);
227 	struct buffer_head * bh;
228 	int bits_per_zone = 8 * sb->s_blocksize;
229 	unsigned long j;
230 	int i;
231 
232 	if (!inode) {
233 		*error = -ENOMEM;
234 		return NULL;
235 	}
236 	j = bits_per_zone;
237 	bh = NULL;
238 	*error = -ENOSPC;
239 	lock_kernel();
240 	for (i = 0; i < sbi->s_imap_blocks; i++) {
241 		bh = sbi->s_imap[i];
242 		j = minix_find_first_zero_bit(bh->b_data, bits_per_zone);
243 		if (j < bits_per_zone)
244 			break;
245 	}
246 	if (!bh || j >= bits_per_zone) {
247 		unlock_kernel();
248 		iput(inode);
249 		return NULL;
250 	}
251 	if (minix_test_and_set_bit(j, bh->b_data)) {	/* shouldn't happen */
252 		unlock_kernel();
253 		printk("minix_new_inode: bit already set\n");
254 		iput(inode);
255 		return NULL;
256 	}
257 	unlock_kernel();
258 	mark_buffer_dirty(bh);
259 	j += i * bits_per_zone;
260 	if (!j || j > sbi->s_ninodes) {
261 		iput(inode);
262 		return NULL;
263 	}
264 	inode->i_uid = current->fsuid;
265 	inode->i_gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
266 	inode->i_ino = j;
267 	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
268 	inode->i_blocks = 0;
269 	memset(&minix_i(inode)->u, 0, sizeof(minix_i(inode)->u));
270 	insert_inode_hash(inode);
271 	mark_inode_dirty(inode);
272 
273 	*error = 0;
274 	return inode;
275 }
276 
277 unsigned long minix_count_free_inodes(struct minix_sb_info *sbi)
278 {
279 	return count_free(sbi->s_imap, sbi->s_imap_blocks, sbi->s_ninodes + 1);
280 }
281