Merge tag 'nfs-for-3.9-3' of git://git.linux-nfs.org/projects/trondmy/linux-nfs
[pandora-kernel.git] / fs / affs / bitmap.c
1 /*
2  *  linux/fs/affs/bitmap.c
3  *
4  *  (c) 1996 Hans-Joachim Widmaier
5  *
6  *  bitmap.c contains the code that handles all bitmap related stuff -
7  *  block allocation, deallocation, calculation of free space.
8  */
9
10 #include <linux/slab.h>
11 #include "affs.h"
12
13 u32
14 affs_count_free_blocks(struct super_block *sb)
15 {
16         struct affs_bm_info *bm;
17         u32 free;
18         int i;
19
20         pr_debug("AFFS: count_free_blocks()\n");
21
22         if (sb->s_flags & MS_RDONLY)
23                 return 0;
24
25         mutex_lock(&AFFS_SB(sb)->s_bmlock);
26
27         bm = AFFS_SB(sb)->s_bitmap;
28         free = 0;
29         for (i = AFFS_SB(sb)->s_bmap_count; i > 0; bm++, i--)
30                 free += bm->bm_free;
31
32         mutex_unlock(&AFFS_SB(sb)->s_bmlock);
33
34         return free;
35 }
36
37 void
38 affs_free_block(struct super_block *sb, u32 block)
39 {
40         struct affs_sb_info *sbi = AFFS_SB(sb);
41         struct affs_bm_info *bm;
42         struct buffer_head *bh;
43         u32 blk, bmap, bit, mask, tmp;
44         __be32 *data;
45
46         pr_debug("AFFS: free_block(%u)\n", block);
47
48         if (block > sbi->s_partition_size)
49                 goto err_range;
50
51         blk     = block - sbi->s_reserved;
52         bmap    = blk / sbi->s_bmap_bits;
53         bit     = blk % sbi->s_bmap_bits;
54         bm      = &sbi->s_bitmap[bmap];
55
56         mutex_lock(&sbi->s_bmlock);
57
58         bh = sbi->s_bmap_bh;
59         if (sbi->s_last_bmap != bmap) {
60                 affs_brelse(bh);
61                 bh = affs_bread(sb, bm->bm_key);
62                 if (!bh)
63                         goto err_bh_read;
64                 sbi->s_bmap_bh = bh;
65                 sbi->s_last_bmap = bmap;
66         }
67
68         mask = 1 << (bit & 31);
69         data = (__be32 *)bh->b_data + bit / 32 + 1;
70
71         /* mark block free */
72         tmp = be32_to_cpu(*data);
73         if (tmp & mask)
74                 goto err_free;
75         *data = cpu_to_be32(tmp | mask);
76
77         /* fix checksum */
78         tmp = be32_to_cpu(*(__be32 *)bh->b_data);
79         *(__be32 *)bh->b_data = cpu_to_be32(tmp - mask);
80
81         mark_buffer_dirty(bh);
82         affs_mark_sb_dirty(sb);
83         bm->bm_free++;
84
85         mutex_unlock(&sbi->s_bmlock);
86         return;
87
88 err_free:
89         affs_warning(sb,"affs_free_block","Trying to free block %u which is already free", block);
90         mutex_unlock(&sbi->s_bmlock);
91         return;
92
93 err_bh_read:
94         affs_error(sb,"affs_free_block","Cannot read bitmap block %u", bm->bm_key);
95         sbi->s_bmap_bh = NULL;
96         sbi->s_last_bmap = ~0;
97         mutex_unlock(&sbi->s_bmlock);
98         return;
99
100 err_range:
101         affs_error(sb, "affs_free_block","Block %u outside partition", block);
102         return;
103 }
104
105 /*
106  * Allocate a block in the given allocation zone.
107  * Since we have to byte-swap the bitmap on little-endian
108  * machines, this is rather expensive. Therefore we will
109  * preallocate up to 16 blocks from the same word, if
110  * possible. We are not doing preallocations in the
111  * header zone, though.
112  */
113
114 u32
115 affs_alloc_block(struct inode *inode, u32 goal)
116 {
117         struct super_block *sb;
118         struct affs_sb_info *sbi;
119         struct affs_bm_info *bm;
120         struct buffer_head *bh;
121         __be32 *data, *enddata;
122         u32 blk, bmap, bit, mask, mask2, tmp;
123         int i;
124
125         sb = inode->i_sb;
126         sbi = AFFS_SB(sb);
127
128         pr_debug("AFFS: balloc(inode=%lu,goal=%u): ", inode->i_ino, goal);
129
130         if (AFFS_I(inode)->i_pa_cnt) {
131                 pr_debug("%d\n", AFFS_I(inode)->i_lastalloc+1);
132                 AFFS_I(inode)->i_pa_cnt--;
133                 return ++AFFS_I(inode)->i_lastalloc;
134         }
135
136         if (!goal || goal > sbi->s_partition_size) {
137                 if (goal)
138                         affs_warning(sb, "affs_balloc", "invalid goal %d", goal);
139                 //if (!AFFS_I(inode)->i_last_block)
140                 //      affs_warning(sb, "affs_balloc", "no last alloc block");
141                 goal = sbi->s_reserved;
142         }
143
144         blk = goal - sbi->s_reserved;
145         bmap = blk / sbi->s_bmap_bits;
146         bm = &sbi->s_bitmap[bmap];
147
148         mutex_lock(&sbi->s_bmlock);
149
150         if (bm->bm_free)
151                 goto find_bmap_bit;
152
153 find_bmap:
154         /* search for the next bmap buffer with free bits */
155         i = sbi->s_bmap_count;
156         do {
157                 if (--i < 0)
158                         goto err_full;
159                 bmap++;
160                 bm++;
161                 if (bmap < sbi->s_bmap_count)
162                         continue;
163                 /* restart search at zero */
164                 bmap = 0;
165                 bm = sbi->s_bitmap;
166         } while (!bm->bm_free);
167         blk = bmap * sbi->s_bmap_bits;
168
169 find_bmap_bit:
170
171         bh = sbi->s_bmap_bh;
172         if (sbi->s_last_bmap != bmap) {
173                 affs_brelse(bh);
174                 bh = affs_bread(sb, bm->bm_key);
175                 if (!bh)
176                         goto err_bh_read;
177                 sbi->s_bmap_bh = bh;
178                 sbi->s_last_bmap = bmap;
179         }
180
181         /* find an unused block in this bitmap block */
182         bit = blk % sbi->s_bmap_bits;
183         data = (__be32 *)bh->b_data + bit / 32 + 1;
184         enddata = (__be32 *)((u8 *)bh->b_data + sb->s_blocksize);
185         mask = ~0UL << (bit & 31);
186         blk &= ~31UL;
187
188         tmp = be32_to_cpu(*data);
189         if (tmp & mask)
190                 goto find_bit;
191
192         /* scan the rest of the buffer */
193         do {
194                 blk += 32;
195                 if (++data >= enddata)
196                         /* didn't find something, can only happen
197                          * if scan didn't start at 0, try next bmap
198                          */
199                         goto find_bmap;
200         } while (!*data);
201         tmp = be32_to_cpu(*data);
202         mask = ~0;
203
204 find_bit:
205         /* finally look for a free bit in the word */
206         bit = ffs(tmp & mask) - 1;
207         blk += bit + sbi->s_reserved;
208         mask2 = mask = 1 << (bit & 31);
209         AFFS_I(inode)->i_lastalloc = blk;
210
211         /* prealloc as much as possible within this word */
212         while ((mask2 <<= 1)) {
213                 if (!(tmp & mask2))
214                         break;
215                 AFFS_I(inode)->i_pa_cnt++;
216                 mask |= mask2;
217         }
218         bm->bm_free -= AFFS_I(inode)->i_pa_cnt + 1;
219
220         *data = cpu_to_be32(tmp & ~mask);
221
222         /* fix checksum */
223         tmp = be32_to_cpu(*(__be32 *)bh->b_data);
224         *(__be32 *)bh->b_data = cpu_to_be32(tmp + mask);
225
226         mark_buffer_dirty(bh);
227         affs_mark_sb_dirty(sb);
228
229         mutex_unlock(&sbi->s_bmlock);
230
231         pr_debug("%d\n", blk);
232         return blk;
233
234 err_bh_read:
235         affs_error(sb,"affs_read_block","Cannot read bitmap block %u", bm->bm_key);
236         sbi->s_bmap_bh = NULL;
237         sbi->s_last_bmap = ~0;
238 err_full:
239         mutex_unlock(&sbi->s_bmlock);
240         pr_debug("failed\n");
241         return 0;
242 }
243
244 int affs_init_bitmap(struct super_block *sb, int *flags)
245 {
246         struct affs_bm_info *bm;
247         struct buffer_head *bmap_bh = NULL, *bh = NULL;
248         __be32 *bmap_blk;
249         u32 size, blk, end, offset, mask;
250         int i, res = 0;
251         struct affs_sb_info *sbi = AFFS_SB(sb);
252
253         if (*flags & MS_RDONLY)
254                 return 0;
255
256         if (!AFFS_ROOT_TAIL(sb, sbi->s_root_bh)->bm_flag) {
257                 printk(KERN_NOTICE "AFFS: Bitmap invalid - mounting %s read only\n",
258                         sb->s_id);
259                 *flags |= MS_RDONLY;
260                 return 0;
261         }
262
263         sbi->s_last_bmap = ~0;
264         sbi->s_bmap_bh = NULL;
265         sbi->s_bmap_bits = sb->s_blocksize * 8 - 32;
266         sbi->s_bmap_count = (sbi->s_partition_size - sbi->s_reserved +
267                                  sbi->s_bmap_bits - 1) / sbi->s_bmap_bits;
268         size = sbi->s_bmap_count * sizeof(*bm);
269         bm = sbi->s_bitmap = kzalloc(size, GFP_KERNEL);
270         if (!sbi->s_bitmap) {
271                 printk(KERN_ERR "AFFS: Bitmap allocation failed\n");
272                 return -ENOMEM;
273         }
274
275         bmap_blk = (__be32 *)sbi->s_root_bh->b_data;
276         blk = sb->s_blocksize / 4 - 49;
277         end = blk + 25;
278
279         for (i = sbi->s_bmap_count; i > 0; bm++, i--) {
280                 affs_brelse(bh);
281
282                 bm->bm_key = be32_to_cpu(bmap_blk[blk]);
283                 bh = affs_bread(sb, bm->bm_key);
284                 if (!bh) {
285                         printk(KERN_ERR "AFFS: Cannot read bitmap\n");
286                         res = -EIO;
287                         goto out;
288                 }
289                 if (affs_checksum_block(sb, bh)) {
290                         printk(KERN_WARNING "AFFS: Bitmap %u invalid - mounting %s read only.\n",
291                                bm->bm_key, sb->s_id);
292                         *flags |= MS_RDONLY;
293                         goto out;
294                 }
295                 pr_debug("AFFS: read bitmap block %d: %d\n", blk, bm->bm_key);
296                 bm->bm_free = memweight(bh->b_data + 4, sb->s_blocksize - 4);
297
298                 /* Don't try read the extension if this is the last block,
299                  * but we also need the right bm pointer below
300                  */
301                 if (++blk < end || i == 1)
302                         continue;
303                 if (bmap_bh)
304                         affs_brelse(bmap_bh);
305                 bmap_bh = affs_bread(sb, be32_to_cpu(bmap_blk[blk]));
306                 if (!bmap_bh) {
307                         printk(KERN_ERR "AFFS: Cannot read bitmap extension\n");
308                         res = -EIO;
309                         goto out;
310                 }
311                 bmap_blk = (__be32 *)bmap_bh->b_data;
312                 blk = 0;
313                 end = sb->s_blocksize / 4 - 1;
314         }
315
316         offset = (sbi->s_partition_size - sbi->s_reserved) % sbi->s_bmap_bits;
317         mask = ~(0xFFFFFFFFU << (offset & 31));
318         pr_debug("last word: %d %d %d\n", offset, offset / 32 + 1, mask);
319         offset = offset / 32 + 1;
320
321         if (mask) {
322                 u32 old, new;
323
324                 /* Mark unused bits in the last word as allocated */
325                 old = be32_to_cpu(((__be32 *)bh->b_data)[offset]);
326                 new = old & mask;
327                 //if (old != new) {
328                         ((__be32 *)bh->b_data)[offset] = cpu_to_be32(new);
329                         /* fix checksum */
330                         //new -= old;
331                         //old = be32_to_cpu(*(__be32 *)bh->b_data);
332                         //*(__be32 *)bh->b_data = cpu_to_be32(old - new);
333                         //mark_buffer_dirty(bh);
334                 //}
335                 /* correct offset for the bitmap count below */
336                 //offset++;
337         }
338         while (++offset < sb->s_blocksize / 4)
339                 ((__be32 *)bh->b_data)[offset] = 0;
340         ((__be32 *)bh->b_data)[0] = 0;
341         ((__be32 *)bh->b_data)[0] = cpu_to_be32(-affs_checksum_block(sb, bh));
342         mark_buffer_dirty(bh);
343
344         /* recalculate bitmap count for last block */
345         bm--;
346         bm->bm_free = memweight(bh->b_data + 4, sb->s_blocksize - 4);
347
348 out:
349         affs_brelse(bh);
350         affs_brelse(bmap_bh);
351         return res;
352 }
353
354 void affs_free_bitmap(struct super_block *sb)
355 {
356         struct affs_sb_info *sbi = AFFS_SB(sb);
357
358         if (!sbi->s_bitmap)
359                 return;
360
361         affs_brelse(sbi->s_bmap_bh);
362         sbi->s_bmap_bh = NULL;
363         sbi->s_last_bmap = ~0;
364         kfree(sbi->s_bitmap);
365         sbi->s_bitmap = NULL;
366 }