blob: b286ccb085879172a6bac6f5055c14b4c3cd363a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
3 */
4/* Reiserfs block (de)allocator, bitmap-based. */
5
Linus Torvalds1da177e2005-04-16 15:20:36 -07006#include <linux/time.h>
7#include <linux/reiserfs_fs.h>
8#include <linux/errno.h>
9#include <linux/buffer_head.h>
10#include <linux/kernel.h>
11#include <linux/pagemap.h>
Jeff Mahoney6f010462006-09-30 23:28:43 -070012#include <linux/vmalloc.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/reiserfs_fs_sb.h>
14#include <linux/reiserfs_fs_i.h>
15#include <linux/quotaops.h>
16
17#define PREALLOCATION_SIZE 9
18
19/* different reiserfs block allocator options */
20
21#define SB_ALLOC_OPTS(s) (REISERFS_SB(s)->s_alloc_options.bits)
22
23#define _ALLOC_concentrating_formatted_nodes 0
24#define _ALLOC_displacing_large_files 1
25#define _ALLOC_displacing_new_packing_localities 2
26#define _ALLOC_old_hashed_relocation 3
27#define _ALLOC_new_hashed_relocation 4
28#define _ALLOC_skip_busy 5
29#define _ALLOC_displace_based_on_dirid 6
30#define _ALLOC_hashed_formatted_nodes 7
31#define _ALLOC_old_way 8
32#define _ALLOC_hundredth_slices 9
33#define _ALLOC_dirid_groups 10
34#define _ALLOC_oid_groups 11
35#define _ALLOC_packing_groups 12
36
37#define concentrating_formatted_nodes(s) test_bit(_ALLOC_concentrating_formatted_nodes, &SB_ALLOC_OPTS(s))
38#define displacing_large_files(s) test_bit(_ALLOC_displacing_large_files, &SB_ALLOC_OPTS(s))
39#define displacing_new_packing_localities(s) test_bit(_ALLOC_displacing_new_packing_localities, &SB_ALLOC_OPTS(s))
40
41#define SET_OPTION(optname) \
42 do { \
43 reiserfs_warning(s, "reiserfs: option \"%s\" is set", #optname); \
44 set_bit(_ALLOC_ ## optname , &SB_ALLOC_OPTS(s)); \
45 } while(0)
46#define TEST_OPTION(optname, s) \
47 test_bit(_ALLOC_ ## optname , &SB_ALLOC_OPTS(s))
48
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070049static inline void get_bit_address(struct super_block *s,
50 b_blocknr_t block, int *bmap_nr, int *offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -070051{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070052 /* It is in the bitmap block number equal to the block
53 * number divided by the number of bits in a block. */
Jeff Mahoneye1fabd32006-09-30 23:28:40 -070054 *bmap_nr = block >> (s->s_blocksize_bits + 3);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070055 /* Within that bitmap block it is located at bit offset *offset. */
56 *offset = block & ((s->s_blocksize << 3) - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -070057}
58
59#ifdef CONFIG_REISERFS_CHECK
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070060int is_reusable(struct super_block *s, b_blocknr_t block, int bit_value)
Linus Torvalds1da177e2005-04-16 15:20:36 -070061{
Jeff Mahoneye1fabd32006-09-30 23:28:40 -070062 int bmap, offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070064 if (block == 0 || block >= SB_BLOCK_COUNT(s)) {
65 reiserfs_warning(s,
66 "vs-4010: is_reusable: block number is out of range %lu (%u)",
67 block, SB_BLOCK_COUNT(s));
68 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
Jeff Mahoneye1fabd32006-09-30 23:28:40 -070071 get_bit_address(s, block, &bmap, &offset);
72
73 /* Old format filesystem? Unlikely, but the bitmaps are all up front so
74 * we need to account for it. */
75 if (unlikely(test_bit(REISERFS_OLD_FORMAT,
76 &(REISERFS_SB(s)->s_properties)))) {
77 b_blocknr_t bmap1 = REISERFS_SB(s)->s_sbh->b_blocknr + 1;
78 if (block >= bmap1 && block <= bmap1 + SB_BMAP_NR(s)) {
79 reiserfs_warning(s, "vs: 4019: is_reusable: "
80 "bitmap block %lu(%u) can't be freed or reused",
81 block, SB_BMAP_NR(s));
82 return 0;
83 }
84 } else {
85 if (offset == 0) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070086 reiserfs_warning(s, "vs: 4020: is_reusable: "
87 "bitmap block %lu(%u) can't be freed or reused",
88 block, SB_BMAP_NR(s));
89 return 0;
90 }
Jeff Mahoneye1fabd32006-09-30 23:28:40 -070091 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
Jeff Mahoneye1fabd32006-09-30 23:28:40 -070093 if (bmap >= SB_BMAP_NR(s)) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070094 reiserfs_warning(s,
95 "vs-4030: is_reusable: there is no so many bitmap blocks: "
Jeff Mahoneye1fabd32006-09-30 23:28:40 -070096 "block=%lu, bitmap_nr=%d", block, bmap);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070097 return 0;
98 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700100 if (bit_value == 0 && block == SB_ROOT_BLOCK(s)) {
101 reiserfs_warning(s,
102 "vs-4050: is_reusable: this is root block (%u), "
103 "it must be busy", SB_ROOT_BLOCK(s));
104 return 0;
105 }
106
107 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108}
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700109#endif /* CONFIG_REISERFS_CHECK */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
111/* searches in journal structures for a given block number (bmap, off). If block
112 is found in reiserfs journal it suggests next free block candidate to test. */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700113static inline int is_block_in_journal(struct super_block *s, int bmap, int
114 off, int *next)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700116 b_blocknr_t tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700118 if (reiserfs_in_journal(s, bmap, off, 1, &tmp)) {
119 if (tmp) { /* hint supplied */
120 *next = tmp;
121 PROC_INFO_INC(s, scan_bitmap.in_journal_hint);
122 } else {
123 (*next) = off + 1; /* inc offset to avoid looping. */
124 PROC_INFO_INC(s, scan_bitmap.in_journal_nohint);
125 }
126 PROC_INFO_INC(s, scan_bitmap.retry);
127 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700129 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130}
131
132/* it searches for a window of zero bits with given minimum and maximum lengths in one bitmap
133 * block; */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700134static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
135 int bmap_n, int *beg, int boundary, int min,
136 int max, int unfm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700138 struct super_block *s = th->t_super;
139 struct reiserfs_bitmap_info *bi = &SB_AP_BITMAP(s)[bmap_n];
Jeff Mahoney0b3dc172006-09-30 23:28:42 -0700140 struct buffer_head *bh;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700141 int end, next;
142 int org = *beg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700144 BUG_ON(!th->t_trans_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700146 RFALSE(bmap_n >= SB_BMAP_NR(s), "Bitmap %d is out of range (0..%d)",
147 bmap_n, SB_BMAP_NR(s) - 1);
148 PROC_INFO_INC(s, scan_bitmap.bmap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149/* this is unclear and lacks comments, explain how journal bitmaps
150 work here for the reader. Convey a sense of the design here. What
151 is a window? */
152/* - I mean `a window of zero bits' as in description of this function - Zam. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700154 if (!bi) {
155 reiserfs_warning(s, "NULL bitmap info pointer for bitmap %d",
156 bmap_n);
157 return 0;
158 }
Jeff Mahoney0b3dc172006-09-30 23:28:42 -0700159
Jeff Mahoney50652272006-09-30 23:28:44 -0700160 bh = reiserfs_read_bitmap_block(s, bmap_n);
161 if (bh == NULL)
162 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700164 while (1) {
165 cont:
Jeff Mahoney0b3dc172006-09-30 23:28:42 -0700166 if (bi->free_count < min) {
167 brelse(bh);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700168 return 0; // No free blocks in this bitmap
Jeff Mahoney0b3dc172006-09-30 23:28:42 -0700169 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700171 /* search for a first zero bit -- beggining of a window */
172 *beg = reiserfs_find_next_zero_le_bit
Jeff Mahoney0b3dc172006-09-30 23:28:42 -0700173 ((unsigned long *)(bh->b_data), boundary, *beg);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700174
175 if (*beg + min > boundary) { /* search for a zero bit fails or the rest of bitmap block
176 * cannot contain a zero window of minimum size */
Jeff Mahoney0b3dc172006-09-30 23:28:42 -0700177 brelse(bh);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700178 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700181 if (unfm && is_block_in_journal(s, bmap_n, *beg, beg))
182 continue;
183 /* first zero bit found; we check next bits */
184 for (end = *beg + 1;; end++) {
185 if (end >= *beg + max || end >= boundary
Jeff Mahoney0b3dc172006-09-30 23:28:42 -0700186 || reiserfs_test_le_bit(end, bh->b_data)) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700187 next = end;
188 break;
189 }
190 /* finding the other end of zero bit window requires looking into journal structures (in
191 * case of searching for free blocks for unformatted nodes) */
192 if (unfm && is_block_in_journal(s, bmap_n, end, &next))
193 break;
194 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700196 /* now (*beg) points to beginning of zero bits window,
197 * (end) points to one bit after the window end */
198 if (end - *beg >= min) { /* it seems we have found window of proper size */
199 int i;
Jeff Mahoney0b3dc172006-09-30 23:28:42 -0700200 reiserfs_prepare_for_journal(s, bh, 1);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700201 /* try to set all blocks used checking are they still free */
202 for (i = *beg; i < end; i++) {
203 /* It seems that we should not check in journal again. */
204 if (reiserfs_test_and_set_le_bit
Jeff Mahoney0b3dc172006-09-30 23:28:42 -0700205 (i, bh->b_data)) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700206 /* bit was set by another process
207 * while we slept in prepare_for_journal() */
208 PROC_INFO_INC(s, scan_bitmap.stolen);
209 if (i >= *beg + min) { /* we can continue with smaller set of allocated blocks,
210 * if length of this set is more or equal to `min' */
211 end = i;
212 break;
213 }
214 /* otherwise we clear all bit were set ... */
215 while (--i >= *beg)
216 reiserfs_test_and_clear_le_bit
Jeff Mahoney0b3dc172006-09-30 23:28:42 -0700217 (i, bh->b_data);
218 reiserfs_restore_prepared_buffer(s, bh);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700219 *beg = org;
220 /* ... and search again in current block from beginning */
221 goto cont;
222 }
223 }
224 bi->free_count -= (end - *beg);
Jeff Mahoney0b3dc172006-09-30 23:28:42 -0700225 journal_mark_dirty(th, s, bh);
226 brelse(bh);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700227
228 /* free block count calculation */
229 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s),
230 1);
231 PUT_SB_FREE_BLOCKS(s, SB_FREE_BLOCKS(s) - (end - *beg));
232 journal_mark_dirty(th, s, SB_BUFFER_WITH_SB(s));
233
234 return end - (*beg);
235 } else {
236 *beg = next;
237 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239}
240
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700241static int bmap_hash_id(struct super_block *s, u32 id)
242{
243 char *hash_in = NULL;
244 unsigned long hash;
245 unsigned bm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700247 if (id <= 2) {
248 bm = 1;
249 } else {
250 hash_in = (char *)(&id);
251 hash = keyed_hash(hash_in, 4);
252 bm = hash % SB_BMAP_NR(s);
253 if (!bm)
254 bm = 1;
255 }
256 /* this can only be true when SB_BMAP_NR = 1 */
257 if (bm >= SB_BMAP_NR(s))
258 bm = 0;
259 return bm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260}
261
262/*
263 * hashes the id and then returns > 0 if the block group for the
264 * corresponding hash is full
265 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700266static inline int block_group_used(struct super_block *s, u32 id)
267{
Jeff Mahoney50652272006-09-30 23:28:44 -0700268 int bm = bmap_hash_id(s, id);
269 struct reiserfs_bitmap_info *info = &SB_AP_BITMAP(s)[bm];
270
271 /* If we don't have cached information on this bitmap block, we're
272 * going to have to load it later anyway. Loading it here allows us
273 * to make a better decision. This favors long-term performace gain
274 * with a better on-disk layout vs. a short term gain of skipping the
275 * read and potentially having a bad placement. */
276 if (info->first_zero_hint == 0) {
277 struct buffer_head *bh = reiserfs_read_bitmap_block(s, bm);
278 brelse(bh);
279 }
280
281 if (info->free_count > ((s->s_blocksize << 3) * 60 / 100)) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700282 return 0;
283 }
284 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285}
286
287/*
288 * the packing is returned in disk byte order
289 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700290__le32 reiserfs_choose_packing(struct inode * dir)
Al Viro3e8962b2005-05-01 08:59:18 -0700291{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700292 __le32 packing;
293 if (TEST_OPTION(packing_groups, dir->i_sb)) {
294 u32 parent_dir = le32_to_cpu(INODE_PKEY(dir)->k_dir_id);
295 /*
296 * some versions of reiserfsck expect packing locality 1 to be
297 * special
298 */
299 if (parent_dir == 1 || block_group_used(dir->i_sb, parent_dir))
300 packing = INODE_PKEY(dir)->k_objectid;
301 else
302 packing = INODE_PKEY(dir)->k_dir_id;
303 } else
304 packing = INODE_PKEY(dir)->k_objectid;
305 return packing;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306}
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700307
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308/* Tries to find contiguous zero bit window (given size) in given region of
309 * bitmap and place new blocks there. Returns number of allocated blocks. */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700310static int scan_bitmap(struct reiserfs_transaction_handle *th,
311 b_blocknr_t * start, b_blocknr_t finish,
312 int min, int max, int unfm, unsigned long file_block)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700314 int nr_allocated = 0;
315 struct super_block *s = th->t_super;
316 /* find every bm and bmap and bmap_nr in this file, and change them all to bitmap_blocknr
317 * - Hans, it is not a block number - Zam. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700319 int bm, off;
320 int end_bm, end_off;
321 int off_max = s->s_blocksize << 3;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700323 BUG_ON(!th->t_trans_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700325 PROC_INFO_INC(s, scan_bitmap.call);
326 if (SB_FREE_BLOCKS(s) <= 0)
327 return 0; // No point in looking for more free blocks
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700329 get_bit_address(s, *start, &bm, &off);
330 get_bit_address(s, finish, &end_bm, &end_off);
331 if (bm > SB_BMAP_NR(s))
332 return 0;
333 if (end_bm > SB_BMAP_NR(s))
334 end_bm = SB_BMAP_NR(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700336 /* When the bitmap is more than 10% free, anyone can allocate.
337 * When it's less than 10% free, only files that already use the
338 * bitmap are allowed. Once we pass 80% full, this restriction
339 * is lifted.
340 *
341 * We do this so that files that grow later still have space close to
342 * their original allocation. This improves locality, and presumably
343 * performance as a result.
344 *
345 * This is only an allocation policy and does not make up for getting a
346 * bad hint. Decent hinting must be implemented for this to work well.
347 */
348 if (TEST_OPTION(skip_busy, s)
349 && SB_FREE_BLOCKS(s) > SB_BLOCK_COUNT(s) / 20) {
350 for (; bm < end_bm; bm++, off = 0) {
351 if ((off && (!unfm || (file_block != 0)))
352 || SB_AP_BITMAP(s)[bm].free_count >
353 (s->s_blocksize << 3) / 10)
354 nr_allocated =
355 scan_bitmap_block(th, bm, &off, off_max,
356 min, max, unfm);
357 if (nr_allocated)
358 goto ret;
359 }
360 /* we know from above that start is a reasonable number */
361 get_bit_address(s, *start, &bm, &off);
362 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700364 for (; bm < end_bm; bm++, off = 0) {
365 nr_allocated =
366 scan_bitmap_block(th, bm, &off, off_max, min, max, unfm);
367 if (nr_allocated)
368 goto ret;
369 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700371 nr_allocated =
372 scan_bitmap_block(th, bm, &off, end_off + 1, min, max, unfm);
373
374 ret:
375 *start = bm * off_max + off;
376 return nr_allocated;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377
378}
379
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700380static void _reiserfs_free_block(struct reiserfs_transaction_handle *th,
381 struct inode *inode, b_blocknr_t block,
382 int for_unformatted)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700384 struct super_block *s = th->t_super;
385 struct reiserfs_super_block *rs;
Jeff Mahoney0b3dc172006-09-30 23:28:42 -0700386 struct buffer_head *sbh, *bmbh;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700387 struct reiserfs_bitmap_info *apbi;
388 int nr, offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700390 BUG_ON(!th->t_trans_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700392 PROC_INFO_INC(s, free_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700394 rs = SB_DISK_SUPER_BLOCK(s);
395 sbh = SB_BUFFER_WITH_SB(s);
396 apbi = SB_AP_BITMAP(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700398 get_bit_address(s, block, &nr, &offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700400 if (nr >= sb_bmap_nr(rs)) {
401 reiserfs_warning(s, "vs-4075: reiserfs_free_block: "
402 "block %lu is out of range on %s",
403 block, reiserfs_bdevname(s));
404 return;
405 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406
Jeff Mahoney50652272006-09-30 23:28:44 -0700407 bmbh = reiserfs_read_bitmap_block(s, nr);
408 if (!bmbh)
409 return;
Jeff Mahoney0b3dc172006-09-30 23:28:42 -0700410
411 reiserfs_prepare_for_journal(s, bmbh, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700413 /* clear bit for the given block in bit map */
Jeff Mahoney0b3dc172006-09-30 23:28:42 -0700414 if (!reiserfs_test_and_clear_le_bit(offset, bmbh->b_data)) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700415 reiserfs_warning(s, "vs-4080: reiserfs_free_block: "
416 "free_block (%s:%lu)[dev:blocknr]: bit already cleared",
417 reiserfs_bdevname(s), block);
418 }
419 apbi[nr].free_count++;
Jeff Mahoney0b3dc172006-09-30 23:28:42 -0700420 journal_mark_dirty(th, s, bmbh);
421 brelse(bmbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700423 reiserfs_prepare_for_journal(s, sbh, 1);
424 /* update super block */
425 set_sb_free_blocks(rs, sb_free_blocks(rs) + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700427 journal_mark_dirty(th, s, sbh);
428 if (for_unformatted)
429 DQUOT_FREE_BLOCK_NODIRTY(inode, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430}
431
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700432void reiserfs_free_block(struct reiserfs_transaction_handle *th,
433 struct inode *inode, b_blocknr_t block,
434 int for_unformatted)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700436 struct super_block *s = th->t_super;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700438 BUG_ON(!th->t_trans_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700440 RFALSE(!s, "vs-4061: trying to free block on nonexistent device");
441 RFALSE(is_reusable(s, block, 1) == 0,
442 "vs-4071: can not free such block");
443 /* mark it before we clear it, just in case */
444 journal_mark_freed(th, s, block);
445 _reiserfs_free_block(th, inode, block, for_unformatted);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446}
447
448/* preallocated blocks don't need to be run through journal_mark_freed */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700449static void reiserfs_free_prealloc_block(struct reiserfs_transaction_handle *th,
450 struct inode *inode, b_blocknr_t block)
451{
452 RFALSE(!th->t_super,
453 "vs-4060: trying to free block on nonexistent device");
454 RFALSE(is_reusable(th->t_super, block, 1) == 0,
455 "vs-4070: can not free such block");
456 BUG_ON(!th->t_trans_id);
457 _reiserfs_free_block(th, inode, block, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458}
459
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700460static void __discard_prealloc(struct reiserfs_transaction_handle *th,
461 struct reiserfs_inode_info *ei)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700463 unsigned long save = ei->i_prealloc_block;
464 int dirty = 0;
465 struct inode *inode = &ei->vfs_inode;
466 BUG_ON(!th->t_trans_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467#ifdef CONFIG_REISERFS_CHECK
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700468 if (ei->i_prealloc_count < 0)
469 reiserfs_warning(th->t_super,
470 "zam-4001:%s: inode has negative prealloc blocks count.",
471 __FUNCTION__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472#endif
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700473 while (ei->i_prealloc_count > 0) {
474 reiserfs_free_prealloc_block(th, inode, ei->i_prealloc_block);
475 ei->i_prealloc_block++;
476 ei->i_prealloc_count--;
477 dirty = 1;
478 }
479 if (dirty)
480 reiserfs_update_sd(th, inode);
481 ei->i_prealloc_block = save;
482 list_del_init(&(ei->i_prealloc_list));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483}
484
485/* FIXME: It should be inline function */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700486void reiserfs_discard_prealloc(struct reiserfs_transaction_handle *th,
487 struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700489 struct reiserfs_inode_info *ei = REISERFS_I(inode);
490 BUG_ON(!th->t_trans_id);
491 if (ei->i_prealloc_count)
492 __discard_prealloc(th, ei);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493}
494
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700495void reiserfs_discard_all_prealloc(struct reiserfs_transaction_handle *th)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700497 struct list_head *plist = &SB_JOURNAL(th->t_super)->j_prealloc_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700499 BUG_ON(!th->t_trans_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700501 while (!list_empty(plist)) {
502 struct reiserfs_inode_info *ei;
503 ei = list_entry(plist->next, struct reiserfs_inode_info,
504 i_prealloc_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505#ifdef CONFIG_REISERFS_CHECK
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700506 if (!ei->i_prealloc_count) {
507 reiserfs_warning(th->t_super,
508 "zam-4001:%s: inode is in prealloc list but has no preallocated blocks.",
509 __FUNCTION__);
510 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511#endif
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700512 __discard_prealloc(th, ei);
513 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514}
515
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700516void reiserfs_init_alloc_options(struct super_block *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700518 set_bit(_ALLOC_skip_busy, &SB_ALLOC_OPTS(s));
519 set_bit(_ALLOC_dirid_groups, &SB_ALLOC_OPTS(s));
520 set_bit(_ALLOC_packing_groups, &SB_ALLOC_OPTS(s));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521}
522
523/* block allocator related options are parsed here */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700524int reiserfs_parse_alloc_options(struct super_block *s, char *options)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700526 char *this_char, *value;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700528 REISERFS_SB(s)->s_alloc_options.bits = 0; /* clear default settings */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700530 while ((this_char = strsep(&options, ":")) != NULL) {
531 if ((value = strchr(this_char, '=')) != NULL)
532 *value++ = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700534 if (!strcmp(this_char, "concentrating_formatted_nodes")) {
535 int temp;
536 SET_OPTION(concentrating_formatted_nodes);
537 temp = (value
538 && *value) ? simple_strtoul(value, &value,
539 0) : 10;
540 if (temp <= 0 || temp > 100) {
541 REISERFS_SB(s)->s_alloc_options.border = 10;
542 } else {
543 REISERFS_SB(s)->s_alloc_options.border =
544 100 / temp;
545 }
546 continue;
547 }
548 if (!strcmp(this_char, "displacing_large_files")) {
549 SET_OPTION(displacing_large_files);
550 REISERFS_SB(s)->s_alloc_options.large_file_size =
551 (value
552 && *value) ? simple_strtoul(value, &value, 0) : 16;
553 continue;
554 }
555 if (!strcmp(this_char, "displacing_new_packing_localities")) {
556 SET_OPTION(displacing_new_packing_localities);
557 continue;
558 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700560 if (!strcmp(this_char, "old_hashed_relocation")) {
561 SET_OPTION(old_hashed_relocation);
562 continue;
563 }
564
565 if (!strcmp(this_char, "new_hashed_relocation")) {
566 SET_OPTION(new_hashed_relocation);
567 continue;
568 }
569
570 if (!strcmp(this_char, "dirid_groups")) {
571 SET_OPTION(dirid_groups);
572 continue;
573 }
574 if (!strcmp(this_char, "oid_groups")) {
575 SET_OPTION(oid_groups);
576 continue;
577 }
578 if (!strcmp(this_char, "packing_groups")) {
579 SET_OPTION(packing_groups);
580 continue;
581 }
582 if (!strcmp(this_char, "hashed_formatted_nodes")) {
583 SET_OPTION(hashed_formatted_nodes);
584 continue;
585 }
586
587 if (!strcmp(this_char, "skip_busy")) {
588 SET_OPTION(skip_busy);
589 continue;
590 }
591
592 if (!strcmp(this_char, "hundredth_slices")) {
593 SET_OPTION(hundredth_slices);
594 continue;
595 }
596
597 if (!strcmp(this_char, "old_way")) {
598 SET_OPTION(old_way);
599 continue;
600 }
601
602 if (!strcmp(this_char, "displace_based_on_dirid")) {
603 SET_OPTION(displace_based_on_dirid);
604 continue;
605 }
606
607 if (!strcmp(this_char, "preallocmin")) {
608 REISERFS_SB(s)->s_alloc_options.preallocmin =
609 (value
610 && *value) ? simple_strtoul(value, &value, 0) : 4;
611 continue;
612 }
613
614 if (!strcmp(this_char, "preallocsize")) {
615 REISERFS_SB(s)->s_alloc_options.preallocsize =
616 (value
617 && *value) ? simple_strtoul(value, &value,
618 0) :
619 PREALLOCATION_SIZE;
620 continue;
621 }
622
623 reiserfs_warning(s, "zam-4001: %s : unknown option - %s",
624 __FUNCTION__, this_char);
625 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 }
627
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700628 reiserfs_warning(s, "allocator options = [%08x]\n", SB_ALLOC_OPTS(s));
629 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700632static inline void new_hashed_relocation(reiserfs_blocknr_hint_t * hint)
633{
634 char *hash_in;
635 if (hint->formatted_node) {
636 hash_in = (char *)&hint->key.k_dir_id;
637 } else {
638 if (!hint->inode) {
639 //hint->search_start = hint->beg;
640 hash_in = (char *)&hint->key.k_dir_id;
641 } else
642 if (TEST_OPTION(displace_based_on_dirid, hint->th->t_super))
643 hash_in = (char *)(&INODE_PKEY(hint->inode)->k_dir_id);
644 else
645 hash_in =
646 (char *)(&INODE_PKEY(hint->inode)->k_objectid);
647 }
648
649 hint->search_start =
650 hint->beg + keyed_hash(hash_in, 4) % (hint->end - hint->beg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651}
652
653/*
654 * Relocation based on dirid, hashing them into a given bitmap block
655 * files. Formatted nodes are unaffected, a seperate policy covers them
656 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700657static void dirid_groups(reiserfs_blocknr_hint_t * hint)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700659 unsigned long hash;
660 __u32 dirid = 0;
661 int bm = 0;
662 struct super_block *sb = hint->th->t_super;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 if (hint->inode)
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700664 dirid = le32_to_cpu(INODE_PKEY(hint->inode)->k_dir_id);
665 else if (hint->formatted_node)
666 dirid = hint->key.k_dir_id;
667
668 if (dirid) {
669 bm = bmap_hash_id(sb, dirid);
670 hash = bm * (sb->s_blocksize << 3);
671 /* give a portion of the block group to metadata */
672 if (hint->inode)
673 hash += sb->s_blocksize / 2;
674 hint->search_start = hash;
675 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676}
677
678/*
679 * Relocation based on oid, hashing them into a given bitmap block
680 * files. Formatted nodes are unaffected, a seperate policy covers them
681 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700682static void oid_groups(reiserfs_blocknr_hint_t * hint)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700684 if (hint->inode) {
685 unsigned long hash;
686 __u32 oid;
687 __u32 dirid;
688 int bm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700690 dirid = le32_to_cpu(INODE_PKEY(hint->inode)->k_dir_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700692 /* keep the root dir and it's first set of subdirs close to
693 * the start of the disk
694 */
695 if (dirid <= 2)
696 hash = (hint->inode->i_sb->s_blocksize << 3);
697 else {
698 oid = le32_to_cpu(INODE_PKEY(hint->inode)->k_objectid);
699 bm = bmap_hash_id(hint->inode->i_sb, oid);
700 hash = bm * (hint->inode->i_sb->s_blocksize << 3);
701 }
702 hint->search_start = hash;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704}
705
706/* returns 1 if it finds an indirect item and gets valid hint info
707 * from it, otherwise 0
708 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700709static int get_left_neighbor(reiserfs_blocknr_hint_t * hint)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710{
Josef "Jeff" Sipekfec6d052006-12-08 02:36:32 -0800711 struct treepath *path;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700712 struct buffer_head *bh;
713 struct item_head *ih;
714 int pos_in_item;
715 __le32 *item;
716 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700718 if (!hint->path) /* reiserfs code can call this function w/o pointer to path
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 * structure supplied; then we rely on supplied search_start */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700720 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700722 path = hint->path;
723 bh = get_last_bh(path);
724 RFALSE(!bh, "green-4002: Illegal path specified to get_left_neighbor");
725 ih = get_ih(path);
726 pos_in_item = path->pos_in_item;
727 item = get_item(path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700729 hint->search_start = bh->b_blocknr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700731 if (!hint->formatted_node && is_indirect_le_ih(ih)) {
732 /* for indirect item: go to left and look for the first non-hole entry
733 in the indirect item */
734 if (pos_in_item == I_UNFM_NUM(ih))
735 pos_in_item--;
736// pos_in_item = I_UNFM_NUM (ih) - 1;
737 while (pos_in_item >= 0) {
738 int t = get_block_num(item, pos_in_item);
739 if (t) {
740 hint->search_start = t;
741 ret = 1;
742 break;
743 }
744 pos_in_item--;
745 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700748 /* does result value fit into specified region? */
749 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750}
751
752/* should be, if formatted node, then try to put on first part of the device
753 specified as number of percent with mount option device, else try to put
754 on last of device. This is not to say it is good code to do so,
755 but the effect should be measured. */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700756static inline void set_border_in_hint(struct super_block *s,
757 reiserfs_blocknr_hint_t * hint)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700759 b_blocknr_t border =
760 SB_BLOCK_COUNT(s) / REISERFS_SB(s)->s_alloc_options.border;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700762 if (hint->formatted_node)
763 hint->end = border - 1;
764 else
765 hint->beg = border;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766}
767
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700768static inline void displace_large_file(reiserfs_blocknr_hint_t * hint)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700770 if (TEST_OPTION(displace_based_on_dirid, hint->th->t_super))
771 hint->search_start =
772 hint->beg +
773 keyed_hash((char *)(&INODE_PKEY(hint->inode)->k_dir_id),
774 4) % (hint->end - hint->beg);
775 else
776 hint->search_start =
777 hint->beg +
778 keyed_hash((char *)(&INODE_PKEY(hint->inode)->k_objectid),
779 4) % (hint->end - hint->beg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780}
781
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700782static inline void hash_formatted_node(reiserfs_blocknr_hint_t * hint)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700784 char *hash_in;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700786 if (!hint->inode)
787 hash_in = (char *)&hint->key.k_dir_id;
788 else if (TEST_OPTION(displace_based_on_dirid, hint->th->t_super))
789 hash_in = (char *)(&INODE_PKEY(hint->inode)->k_dir_id);
790 else
791 hash_in = (char *)(&INODE_PKEY(hint->inode)->k_objectid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700793 hint->search_start =
794 hint->beg + keyed_hash(hash_in, 4) % (hint->end - hint->beg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795}
796
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700797static inline int
798this_blocknr_allocation_would_make_it_a_large_file(reiserfs_blocknr_hint_t *
799 hint)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700801 return hint->block ==
802 REISERFS_SB(hint->th->t_super)->s_alloc_options.large_file_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803}
804
805#ifdef DISPLACE_NEW_PACKING_LOCALITIES
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700806static inline void displace_new_packing_locality(reiserfs_blocknr_hint_t * hint)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700808 struct in_core_key *key = &hint->key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700810 hint->th->displace_new_blocks = 0;
811 hint->search_start =
812 hint->beg + keyed_hash((char *)(&key->k_objectid),
813 4) % (hint->end - hint->beg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700817static inline int old_hashed_relocation(reiserfs_blocknr_hint_t * hint)
818{
819 b_blocknr_t border;
820 u32 hash_in;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700822 if (hint->formatted_node || hint->inode == NULL) {
823 return 0;
824 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700826 hash_in = le32_to_cpu((INODE_PKEY(hint->inode))->k_dir_id);
827 border =
828 hint->beg + (u32) keyed_hash(((char *)(&hash_in)),
829 4) % (hint->end - hint->beg - 1);
830 if (border > hint->search_start)
831 hint->search_start = border;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700833 return 1;
834}
835
836static inline int old_way(reiserfs_blocknr_hint_t * hint)
837{
838 b_blocknr_t border;
839
840 if (hint->formatted_node || hint->inode == NULL) {
841 return 0;
842 }
843
844 border =
845 hint->beg +
846 le32_to_cpu(INODE_PKEY(hint->inode)->k_dir_id) % (hint->end -
847 hint->beg);
848 if (border > hint->search_start)
849 hint->search_start = border;
850
851 return 1;
852}
853
854static inline void hundredth_slices(reiserfs_blocknr_hint_t * hint)
855{
856 struct in_core_key *key = &hint->key;
857 b_blocknr_t slice_start;
858
859 slice_start =
860 (keyed_hash((char *)(&key->k_dir_id), 4) % 100) * (hint->end / 100);
861 if (slice_start > hint->search_start
862 || slice_start + (hint->end / 100) <= hint->search_start) {
863 hint->search_start = slice_start;
864 }
865}
866
867static void determine_search_start(reiserfs_blocknr_hint_t * hint,
868 int amount_needed)
869{
870 struct super_block *s = hint->th->t_super;
871 int unfm_hint;
872
873 hint->beg = 0;
874 hint->end = SB_BLOCK_COUNT(s) - 1;
875
876 /* This is former border algorithm. Now with tunable border offset */
877 if (concentrating_formatted_nodes(s))
878 set_border_in_hint(s, hint);
879
880#ifdef DISPLACE_NEW_PACKING_LOCALITIES
881 /* whenever we create a new directory, we displace it. At first we will
882 hash for location, later we might look for a moderately empty place for
883 it */
884 if (displacing_new_packing_localities(s)
885 && hint->th->displace_new_blocks) {
886 displace_new_packing_locality(hint);
887
888 /* we do not continue determine_search_start,
889 * if new packing locality is being displaced */
890 return;
891 }
892#endif
893
894 /* all persons should feel encouraged to add more special cases here and
895 * test them */
896
897 if (displacing_large_files(s) && !hint->formatted_node
898 && this_blocknr_allocation_would_make_it_a_large_file(hint)) {
899 displace_large_file(hint);
900 return;
901 }
902
903 /* if none of our special cases is relevant, use the left neighbor in the
904 tree order of the new node we are allocating for */
905 if (hint->formatted_node && TEST_OPTION(hashed_formatted_nodes, s)) {
906 hash_formatted_node(hint);
907 return;
908 }
909
910 unfm_hint = get_left_neighbor(hint);
911
912 /* Mimic old block allocator behaviour, that is if VFS allowed for preallocation,
913 new blocks are displaced based on directory ID. Also, if suggested search_start
914 is less than last preallocated block, we start searching from it, assuming that
915 HDD dataflow is faster in forward direction */
916 if (TEST_OPTION(old_way, s)) {
917 if (!hint->formatted_node) {
918 if (!reiserfs_hashed_relocation(s))
919 old_way(hint);
920 else if (!reiserfs_no_unhashed_relocation(s))
921 old_hashed_relocation(hint);
922
923 if (hint->inode
924 && hint->search_start <
925 REISERFS_I(hint->inode)->i_prealloc_block)
926 hint->search_start =
927 REISERFS_I(hint->inode)->i_prealloc_block;
928 }
929 return;
930 }
931
932 /* This is an approach proposed by Hans */
933 if (TEST_OPTION(hundredth_slices, s)
934 && !(displacing_large_files(s) && !hint->formatted_node)) {
935 hundredth_slices(hint);
936 return;
937 }
938
939 /* old_hashed_relocation only works on unformatted */
940 if (!unfm_hint && !hint->formatted_node &&
941 TEST_OPTION(old_hashed_relocation, s)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 old_hashed_relocation(hint);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700943 }
944 /* new_hashed_relocation works with both formatted/unformatted nodes */
945 if ((!unfm_hint || hint->formatted_node) &&
946 TEST_OPTION(new_hashed_relocation, s)) {
947 new_hashed_relocation(hint);
948 }
949 /* dirid grouping works only on unformatted nodes */
950 if (!unfm_hint && !hint->formatted_node && TEST_OPTION(dirid_groups, s)) {
951 dirid_groups(hint);
952 }
953#ifdef DISPLACE_NEW_PACKING_LOCALITIES
954 if (hint->formatted_node && TEST_OPTION(dirid_groups, s)) {
955 dirid_groups(hint);
956 }
957#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700959 /* oid grouping works only on unformatted nodes */
960 if (!unfm_hint && !hint->formatted_node && TEST_OPTION(oid_groups, s)) {
961 oid_groups(hint);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 }
963 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964}
965
966static int determine_prealloc_size(reiserfs_blocknr_hint_t * hint)
967{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700968 /* make minimum size a mount option and benchmark both ways */
969 /* we preallocate blocks only for regular files, specific size */
970 /* benchmark preallocating always and see what happens */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700972 hint->prealloc_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700974 if (!hint->formatted_node && hint->preallocate) {
975 if (S_ISREG(hint->inode->i_mode)
976 && hint->inode->i_size >=
977 REISERFS_SB(hint->th->t_super)->s_alloc_options.
978 preallocmin * hint->inode->i_sb->s_blocksize)
979 hint->prealloc_size =
980 REISERFS_SB(hint->th->t_super)->s_alloc_options.
981 preallocsize - 1;
982 }
983 return CARRY_ON;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984}
985
986/* XXX I know it could be merged with upper-level function;
987 but may be result function would be too complex. */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700988static inline int allocate_without_wrapping_disk(reiserfs_blocknr_hint_t * hint,
989 b_blocknr_t * new_blocknrs,
990 b_blocknr_t start,
991 b_blocknr_t finish, int min,
992 int amount_needed,
993 int prealloc_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700995 int rest = amount_needed;
996 int nr_allocated;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700998 while (rest > 0 && start <= finish) {
999 nr_allocated = scan_bitmap(hint->th, &start, finish, min,
1000 rest + prealloc_size,
1001 !hint->formatted_node, hint->block);
1002
1003 if (nr_allocated == 0) /* no new blocks allocated, return */
1004 break;
1005
1006 /* fill free_blocknrs array first */
1007 while (rest > 0 && nr_allocated > 0) {
1008 *new_blocknrs++ = start++;
1009 rest--;
1010 nr_allocated--;
1011 }
1012
1013 /* do we have something to fill prealloc. array also ? */
1014 if (nr_allocated > 0) {
1015 /* it means prealloc_size was greater that 0 and we do preallocation */
1016 list_add(&REISERFS_I(hint->inode)->i_prealloc_list,
1017 &SB_JOURNAL(hint->th->t_super)->
1018 j_prealloc_list);
1019 REISERFS_I(hint->inode)->i_prealloc_block = start;
1020 REISERFS_I(hint->inode)->i_prealloc_count =
1021 nr_allocated;
1022 break;
1023 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 }
1025
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001026 return (amount_needed - rest);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027}
1028
1029static inline int blocknrs_and_prealloc_arrays_from_search_start
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001030 (reiserfs_blocknr_hint_t * hint, b_blocknr_t * new_blocknrs,
1031 int amount_needed) {
1032 struct super_block *s = hint->th->t_super;
1033 b_blocknr_t start = hint->search_start;
1034 b_blocknr_t finish = SB_BLOCK_COUNT(s) - 1;
1035 int passno = 0;
1036 int nr_allocated = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001038 determine_prealloc_size(hint);
1039 if (!hint->formatted_node) {
1040 int quota_ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041#ifdef REISERQUOTA_DEBUG
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001042 reiserfs_debug(s, REISERFS_DEBUG_CODE,
1043 "reiserquota: allocating %d blocks id=%u",
1044 amount_needed, hint->inode->i_uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045#endif
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001046 quota_ret =
1047 DQUOT_ALLOC_BLOCK_NODIRTY(hint->inode, amount_needed);
1048 if (quota_ret) /* Quota exceeded? */
1049 return QUOTA_EXCEEDED;
1050 if (hint->preallocate && hint->prealloc_size) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051#ifdef REISERQUOTA_DEBUG
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001052 reiserfs_debug(s, REISERFS_DEBUG_CODE,
1053 "reiserquota: allocating (prealloc) %d blocks id=%u",
1054 hint->prealloc_size, hint->inode->i_uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055#endif
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001056 quota_ret =
1057 DQUOT_PREALLOC_BLOCK_NODIRTY(hint->inode,
1058 hint->prealloc_size);
1059 if (quota_ret)
1060 hint->preallocate = hint->prealloc_size = 0;
1061 }
1062 /* for unformatted nodes, force large allocations */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001065 do {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001066 switch (passno++) {
1067 case 0: /* Search from hint->search_start to end of disk */
1068 start = hint->search_start;
1069 finish = SB_BLOCK_COUNT(s) - 1;
1070 break;
1071 case 1: /* Search from hint->beg to hint->search_start */
1072 start = hint->beg;
1073 finish = hint->search_start;
1074 break;
1075 case 2: /* Last chance: Search from 0 to hint->beg */
1076 start = 0;
1077 finish = hint->beg;
1078 break;
1079 default: /* We've tried searching everywhere, not enough space */
1080 /* Free the blocks */
1081 if (!hint->formatted_node) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082#ifdef REISERQUOTA_DEBUG
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001083 reiserfs_debug(s, REISERFS_DEBUG_CODE,
1084 "reiserquota: freeing (nospace) %d blocks id=%u",
1085 amount_needed +
1086 hint->prealloc_size -
1087 nr_allocated,
1088 hint->inode->i_uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089#endif
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001090 DQUOT_FREE_BLOCK_NODIRTY(hint->inode, amount_needed + hint->prealloc_size - nr_allocated); /* Free not allocated blocks */
1091 }
1092 while (nr_allocated--)
1093 reiserfs_free_block(hint->th, hint->inode,
1094 new_blocknrs[nr_allocated],
1095 !hint->formatted_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001097 return NO_DISK_SPACE;
1098 }
1099 } while ((nr_allocated += allocate_without_wrapping_disk(hint,
1100 new_blocknrs +
1101 nr_allocated,
1102 start, finish,
Jeff Mahoney9ea0f942006-09-30 23:28:45 -07001103 1,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001104 amount_needed -
1105 nr_allocated,
1106 hint->
1107 prealloc_size))
1108 < amount_needed);
1109 if (!hint->formatted_node &&
1110 amount_needed + hint->prealloc_size >
1111 nr_allocated + REISERFS_I(hint->inode)->i_prealloc_count) {
1112 /* Some of preallocation blocks were not allocated */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113#ifdef REISERQUOTA_DEBUG
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001114 reiserfs_debug(s, REISERFS_DEBUG_CODE,
1115 "reiserquota: freeing (failed prealloc) %d blocks id=%u",
1116 amount_needed + hint->prealloc_size -
1117 nr_allocated -
1118 REISERFS_I(hint->inode)->i_prealloc_count,
1119 hint->inode->i_uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120#endif
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001121 DQUOT_FREE_BLOCK_NODIRTY(hint->inode, amount_needed +
1122 hint->prealloc_size - nr_allocated -
1123 REISERFS_I(hint->inode)->
1124 i_prealloc_count);
1125 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001127 return CARRY_ON;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128}
1129
1130/* grab new blocknrs from preallocated list */
1131/* return amount still needed after using them */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001132static int use_preallocated_list_if_available(reiserfs_blocknr_hint_t * hint,
1133 b_blocknr_t * new_blocknrs,
1134 int amount_needed)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001136 struct inode *inode = hint->inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001138 if (REISERFS_I(inode)->i_prealloc_count > 0) {
1139 while (amount_needed) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001141 *new_blocknrs++ = REISERFS_I(inode)->i_prealloc_block++;
1142 REISERFS_I(inode)->i_prealloc_count--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001144 amount_needed--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001146 if (REISERFS_I(inode)->i_prealloc_count <= 0) {
1147 list_del(&REISERFS_I(inode)->i_prealloc_list);
1148 break;
1149 }
1150 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001152 /* return amount still needed after using preallocated blocks */
1153 return amount_needed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154}
1155
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001156int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t * hint, b_blocknr_t * new_blocknrs, int amount_needed, int reserved_by_us /* Amount of blocks we have
1157 already reserved */ )
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001159 int initial_amount_needed = amount_needed;
1160 int ret;
1161 struct super_block *s = hint->th->t_super;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001163 /* Check if there is enough space, taking into account reserved space */
1164 if (SB_FREE_BLOCKS(s) - REISERFS_SB(s)->reserved_blocks <
1165 amount_needed - reserved_by_us)
1166 return NO_DISK_SPACE;
1167 /* should this be if !hint->inode && hint->preallocate? */
1168 /* do you mean hint->formatted_node can be removed ? - Zam */
1169 /* hint->formatted_node cannot be removed because we try to access
1170 inode information here, and there is often no inode assotiated with
1171 metadata allocations - green */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001173 if (!hint->formatted_node && hint->preallocate) {
1174 amount_needed = use_preallocated_list_if_available
1175 (hint, new_blocknrs, amount_needed);
1176 if (amount_needed == 0) /* all blocknrs we need we got from
1177 prealloc. list */
1178 return CARRY_ON;
1179 new_blocknrs += (initial_amount_needed - amount_needed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001181
1182 /* find search start and save it in hint structure */
1183 determine_search_start(hint, amount_needed);
1184 if (hint->search_start >= SB_BLOCK_COUNT(s))
1185 hint->search_start = SB_BLOCK_COUNT(s) - 1;
1186
1187 /* allocation itself; fill new_blocknrs and preallocation arrays */
1188 ret = blocknrs_and_prealloc_arrays_from_search_start
1189 (hint, new_blocknrs, amount_needed);
1190
1191 /* we used prealloc. list to fill (partially) new_blocknrs array. If final allocation fails we
1192 * need to return blocks back to prealloc. list or just free them. -- Zam (I chose second
1193 * variant) */
1194
1195 if (ret != CARRY_ON) {
1196 while (amount_needed++ < initial_amount_needed) {
1197 reiserfs_free_block(hint->th, hint->inode,
1198 *(--new_blocknrs), 1);
1199 }
1200 }
1201 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202}
1203
1204/* These 2 functions are here to provide blocks reservation to the rest of kernel */
1205/* Reserve @blocks amount of blocks in fs pointed by @sb. Caller must make sure
1206 there are actually this much blocks on the FS available */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001207void reiserfs_claim_blocks_to_be_allocated(struct super_block *sb, /* super block of
1208 filesystem where
1209 blocks should be
1210 reserved */
1211 int blocks /* How much to reserve */
1212 )
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213{
1214
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001215 /* Fast case, if reservation is zero - exit immediately. */
1216 if (!blocks)
1217 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001219 spin_lock(&REISERFS_SB(sb)->bitmap_lock);
1220 REISERFS_SB(sb)->reserved_blocks += blocks;
1221 spin_unlock(&REISERFS_SB(sb)->bitmap_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222}
1223
1224/* Unreserve @blocks amount of blocks in fs pointed by @sb */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001225void reiserfs_release_claimed_blocks(struct super_block *sb, /* super block of
1226 filesystem where
1227 blocks should be
1228 reserved */
1229 int blocks /* How much to unreserve */
1230 )
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231{
1232
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001233 /* Fast case, if unreservation is zero - exit immediately. */
1234 if (!blocks)
1235 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001237 spin_lock(&REISERFS_SB(sb)->bitmap_lock);
1238 REISERFS_SB(sb)->reserved_blocks -= blocks;
1239 spin_unlock(&REISERFS_SB(sb)->bitmap_lock);
1240 RFALSE(REISERFS_SB(sb)->reserved_blocks < 0,
1241 "amount of blocks reserved became zero?");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242}
1243
1244/* This function estimates how much pages we will be able to write to FS
1245 used for reiserfs_file_write() purposes for now. */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001246int reiserfs_can_fit_pages(struct super_block *sb /* superblock of filesystem
1247 to estimate space */ )
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248{
1249 int space;
1250
1251 spin_lock(&REISERFS_SB(sb)->bitmap_lock);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001252 space =
1253 (SB_FREE_BLOCKS(sb) -
1254 REISERFS_SB(sb)->reserved_blocks) >> (PAGE_CACHE_SHIFT -
1255 sb->s_blocksize_bits);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256 spin_unlock(&REISERFS_SB(sb)->bitmap_lock);
1257
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001258 return space > 0 ? space : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259}
Jeff Mahoney6f010462006-09-30 23:28:43 -07001260
1261void reiserfs_cache_bitmap_metadata(struct super_block *sb,
1262 struct buffer_head *bh,
1263 struct reiserfs_bitmap_info *info)
1264{
1265 unsigned long *cur = (unsigned long *)(bh->b_data + bh->b_size);
1266
1267 info->first_zero_hint = 1 << (sb->s_blocksize_bits + 3);
1268
1269 while (--cur >= (unsigned long *)bh->b_data) {
1270 int base = ((char *)cur - bh->b_data) << 3;
1271
1272 /* 0 and ~0 are special, we can optimize for them */
1273 if (*cur == 0) {
1274 info->first_zero_hint = base;
1275 info->free_count += BITS_PER_LONG;
1276 } else if (*cur != ~0L) { /* A mix, investigate */
1277 int b;
1278 for (b = BITS_PER_LONG - 1; b >= 0; b--) {
1279 if (!reiserfs_test_le_bit(b, cur)) {
1280 info->first_zero_hint = base + b;
1281 info->free_count++;
1282 }
1283 }
1284 }
1285 }
1286 /* The first bit must ALWAYS be 1 */
1287 BUG_ON(info->first_zero_hint == 0);
1288}
1289
1290struct buffer_head *reiserfs_read_bitmap_block(struct super_block *sb,
1291 unsigned int bitmap)
1292{
1293 b_blocknr_t block = (sb->s_blocksize << 3) * bitmap;
Jeff Mahoney50652272006-09-30 23:28:44 -07001294 struct reiserfs_bitmap_info *info = SB_AP_BITMAP(sb) + bitmap;
Jeff Mahoney6f010462006-09-30 23:28:43 -07001295 struct buffer_head *bh;
1296
1297 /* Way old format filesystems had the bitmaps packed up front.
1298 * I doubt there are any of these left, but just in case... */
1299 if (unlikely(test_bit(REISERFS_OLD_FORMAT,
1300 &(REISERFS_SB(sb)->s_properties))))
1301 block = REISERFS_SB(sb)->s_sbh->b_blocknr + 1 + bitmap;
1302 else if (bitmap == 0)
1303 block = (REISERFS_DISK_OFFSET_IN_BYTES >> sb->s_blocksize_bits) + 1;
1304
Jeff Mahoney50652272006-09-30 23:28:44 -07001305 bh = sb_bread(sb, block);
1306 if (bh == NULL)
Eric Eric Sesterhenn00079e02006-10-06 22:19:45 -07001307 reiserfs_warning(sb, "sh-2029: %s: bitmap block (#%u) "
1308 "reading failed", __FUNCTION__, block);
Jeff Mahoney50652272006-09-30 23:28:44 -07001309 else {
1310 if (buffer_locked(bh)) {
1311 PROC_INFO_INC(sb, scan_bitmap.wait);
1312 __wait_on_buffer(bh);
1313 }
1314 BUG_ON(!buffer_uptodate(bh));
1315 BUG_ON(atomic_read(&bh->b_count) == 0);
1316
1317 if (info->first_zero_hint == 0)
1318 reiserfs_cache_bitmap_metadata(sb, bh, info);
1319 }
Jeff Mahoney6f010462006-09-30 23:28:43 -07001320
1321 return bh;
1322}
1323
1324int reiserfs_init_bitmap_cache(struct super_block *sb)
1325{
1326 struct reiserfs_bitmap_info *bitmap;
Jeff Mahoney6f010462006-09-30 23:28:43 -07001327
1328 bitmap = vmalloc(sizeof (*bitmap) * SB_BMAP_NR(sb));
1329 if (bitmap == NULL)
1330 return -ENOMEM;
1331
1332 memset(bitmap, 0, sizeof (*bitmap) * SB_BMAP_NR(sb));
1333
Jeff Mahoney6f010462006-09-30 23:28:43 -07001334 SB_AP_BITMAP(sb) = bitmap;
1335
1336 return 0;
1337}
Jeff Mahoney50652272006-09-30 23:28:44 -07001338
1339void reiserfs_free_bitmap_cache(struct super_block *sb)
1340{
1341 if (SB_AP_BITMAP(sb)) {
1342 vfree(SB_AP_BITMAP(sb));
1343 SB_AP_BITMAP(sb) = NULL;
1344 }
1345}