2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
4 /* Reiserfs block (de)allocator, bitmap-based. */
6 #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>
12 #include <linux/reiserfs_fs_sb.h>
13 #include <linux/reiserfs_fs_i.h>
14 #include <linux/quotaops.h>
15 #include <linux/vs_dlimit.h>
17 #define PREALLOCATION_SIZE 9
19 /* different reiserfs block allocator options */
21 #define SB_ALLOC_OPTS(s) (REISERFS_SB(s)->s_alloc_options.bits)
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
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))
41 #define SET_OPTION(optname) \
43 reiserfs_warning(s, "reiserfs: option \"%s\" is set", #optname); \
44 set_bit(_ALLOC_ ## optname , &SB_ALLOC_OPTS(s)); \
46 #define TEST_OPTION(optname, s) \
47 test_bit(_ALLOC_ ## optname , &SB_ALLOC_OPTS(s))
49 static inline void get_bit_address(struct super_block *s,
50 b_blocknr_t block, int *bmap_nr, int *offset)
52 /* It is in the bitmap block number equal to the block
53 * number divided by the number of bits in a block. */
54 *bmap_nr = block / (s->s_blocksize << 3);
55 /* Within that bitmap block it is located at bit offset *offset. */
56 *offset = block & ((s->s_blocksize << 3) - 1);
60 #ifdef CONFIG_REISERFS_CHECK
61 int is_reusable(struct super_block *s, b_blocknr_t block, int bit_value)
65 if (block == 0 || block >= SB_BLOCK_COUNT(s)) {
67 "vs-4010: is_reusable: block number is out of range %lu (%u)",
68 block, SB_BLOCK_COUNT(s));
72 /* it can't be one of the bitmap blocks */
73 for (i = 0; i < SB_BMAP_NR(s); i++)
74 if (block == SB_AP_BITMAP(s)[i].bh->b_blocknr) {
75 reiserfs_warning(s, "vs: 4020: is_reusable: "
76 "bitmap block %lu(%u) can't be freed or reused",
77 block, SB_BMAP_NR(s));
81 get_bit_address(s, block, &i, &j);
83 if (i >= SB_BMAP_NR(s)) {
85 "vs-4030: is_reusable: there is no so many bitmap blocks: "
86 "block=%lu, bitmap_nr=%d", block, i);
90 if ((bit_value == 0 &&
91 reiserfs_test_le_bit(j, SB_AP_BITMAP(s)[i].bh->b_data)) ||
93 reiserfs_test_le_bit(j, SB_AP_BITMAP(s)[i].bh->b_data) == 0)) {
95 "vs-4040: is_reusable: corresponding bit of block %lu does not "
96 "match required value (i==%d, j==%d) test_bit==%d",
97 block, i, j, reiserfs_test_le_bit(j,
105 if (bit_value == 0 && block == SB_ROOT_BLOCK(s)) {
107 "vs-4050: is_reusable: this is root block (%u), "
108 "it must be busy", SB_ROOT_BLOCK(s));
114 #endif /* CONFIG_REISERFS_CHECK */
116 /* searches in journal structures for a given block number (bmap, off). If block
117 is found in reiserfs journal it suggests next free block candidate to test. */
118 static inline int is_block_in_journal(struct super_block *s, int bmap, int
123 if (reiserfs_in_journal(s, bmap, off, 1, &tmp)) {
124 if (tmp) { /* hint supplied */
126 PROC_INFO_INC(s, scan_bitmap.in_journal_hint);
128 (*next) = off + 1; /* inc offset to avoid looping. */
129 PROC_INFO_INC(s, scan_bitmap.in_journal_nohint);
131 PROC_INFO_INC(s, scan_bitmap.retry);
137 /* it searches for a window of zero bits with given minimum and maximum lengths in one bitmap
139 static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
140 int bmap_n, int *beg, int boundary, int min,
143 struct super_block *s = th->t_super;
144 struct reiserfs_bitmap_info *bi = &SB_AP_BITMAP(s)[bmap_n];
148 BUG_ON(!th->t_trans_id);
150 RFALSE(bmap_n >= SB_BMAP_NR(s), "Bitmap %d is out of range (0..%d)",
151 bmap_n, SB_BMAP_NR(s) - 1);
152 PROC_INFO_INC(s, scan_bitmap.bmap);
153 /* this is unclear and lacks comments, explain how journal bitmaps
154 work here for the reader. Convey a sense of the design here. What
156 /* - I mean `a window of zero bits' as in description of this function - Zam. */
159 reiserfs_warning(s, "NULL bitmap info pointer for bitmap %d",
163 if (buffer_locked(bi->bh)) {
164 PROC_INFO_INC(s, scan_bitmap.wait);
165 __wait_on_buffer(bi->bh);
170 if (bi->free_count < min)
171 return 0; // No free blocks in this bitmap
173 /* search for a first zero bit -- beggining of a window */
174 *beg = reiserfs_find_next_zero_le_bit
175 ((unsigned long *)(bi->bh->b_data), boundary, *beg);
177 if (*beg + min > boundary) { /* search for a zero bit fails or the rest of bitmap block
178 * cannot contain a zero window of minimum size */
182 if (unfm && is_block_in_journal(s, bmap_n, *beg, beg))
184 /* first zero bit found; we check next bits */
185 for (end = *beg + 1;; end++) {
186 if (end >= *beg + max || end >= boundary
187 || reiserfs_test_le_bit(end, bi->bh->b_data)) {
191 /* finding the other end of zero bit window requires looking into journal structures (in
192 * case of searching for free blocks for unformatted nodes) */
193 if (unfm && is_block_in_journal(s, bmap_n, end, &next))
197 /* now (*beg) points to beginning of zero bits window,
198 * (end) points to one bit after the window end */
199 if (end - *beg >= min) { /* it seems we have found window of proper size */
201 reiserfs_prepare_for_journal(s, bi->bh, 1);
202 /* try to set all blocks used checking are they still free */
203 for (i = *beg; i < end; i++) {
204 /* It seems that we should not check in journal again. */
205 if (reiserfs_test_and_set_le_bit
206 (i, bi->bh->b_data)) {
207 /* bit was set by another process
208 * while we slept in prepare_for_journal() */
209 PROC_INFO_INC(s, scan_bitmap.stolen);
210 if (i >= *beg + min) { /* we can continue with smaller set of allocated blocks,
211 * if length of this set is more or equal to `min' */
215 /* otherwise we clear all bit were set ... */
217 reiserfs_test_and_clear_le_bit
219 reiserfs_restore_prepared_buffer(s,
223 /* ... and search again in current block from beginning */
227 bi->free_count -= (end - *beg);
228 journal_mark_dirty(th, s, bi->bh);
230 /* free block count calculation */
231 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s),
233 PUT_SB_FREE_BLOCKS(s, SB_FREE_BLOCKS(s) - (end - *beg));
234 journal_mark_dirty(th, s, SB_BUFFER_WITH_SB(s));
243 static int bmap_hash_id(struct super_block *s, u32 id)
245 char *hash_in = NULL;
252 hash_in = (char *)(&id);
253 hash = keyed_hash(hash_in, 4);
254 bm = hash % SB_BMAP_NR(s);
258 /* this can only be true when SB_BMAP_NR = 1 */
259 if (bm >= SB_BMAP_NR(s))
265 * hashes the id and then returns > 0 if the block group for the
266 * corresponding hash is full
268 static inline int block_group_used(struct super_block *s, u32 id)
271 bm = bmap_hash_id(s, id);
272 if (SB_AP_BITMAP(s)[bm].free_count > ((s->s_blocksize << 3) * 60 / 100)) {
279 * the packing is returned in disk byte order
281 __le32 reiserfs_choose_packing(struct inode * dir)
284 if (TEST_OPTION(packing_groups, dir->i_sb)) {
285 u32 parent_dir = le32_to_cpu(INODE_PKEY(dir)->k_dir_id);
287 * some versions of reiserfsck expect packing locality 1 to be
290 if (parent_dir == 1 || block_group_used(dir->i_sb, parent_dir))
291 packing = INODE_PKEY(dir)->k_objectid;
293 packing = INODE_PKEY(dir)->k_dir_id;
295 packing = INODE_PKEY(dir)->k_objectid;
299 /* Tries to find contiguous zero bit window (given size) in given region of
300 * bitmap and place new blocks there. Returns number of allocated blocks. */
301 static int scan_bitmap(struct reiserfs_transaction_handle *th,
302 b_blocknr_t * start, b_blocknr_t finish,
303 int min, int max, int unfm, unsigned long file_block)
305 int nr_allocated = 0;
306 struct super_block *s = th->t_super;
307 /* find every bm and bmap and bmap_nr in this file, and change them all to bitmap_blocknr
308 * - Hans, it is not a block number - Zam. */
312 int off_max = s->s_blocksize << 3;
314 BUG_ON(!th->t_trans_id);
316 PROC_INFO_INC(s, scan_bitmap.call);
317 if (SB_FREE_BLOCKS(s) <= 0)
318 return 0; // No point in looking for more free blocks
320 get_bit_address(s, *start, &bm, &off);
321 get_bit_address(s, finish, &end_bm, &end_off);
322 if (bm > SB_BMAP_NR(s))
324 if (end_bm > SB_BMAP_NR(s))
325 end_bm = SB_BMAP_NR(s);
327 /* When the bitmap is more than 10% free, anyone can allocate.
328 * When it's less than 10% free, only files that already use the
329 * bitmap are allowed. Once we pass 80% full, this restriction
332 * We do this so that files that grow later still have space close to
333 * their original allocation. This improves locality, and presumably
334 * performance as a result.
336 * This is only an allocation policy and does not make up for getting a
337 * bad hint. Decent hinting must be implemented for this to work well.
339 if (TEST_OPTION(skip_busy, s)
340 && SB_FREE_BLOCKS(s) > SB_BLOCK_COUNT(s) / 20) {
341 for (; bm < end_bm; bm++, off = 0) {
342 if ((off && (!unfm || (file_block != 0)))
343 || SB_AP_BITMAP(s)[bm].free_count >
344 (s->s_blocksize << 3) / 10)
346 scan_bitmap_block(th, bm, &off, off_max,
351 /* we know from above that start is a reasonable number */
352 get_bit_address(s, *start, &bm, &off);
355 for (; bm < end_bm; bm++, off = 0) {
357 scan_bitmap_block(th, bm, &off, off_max, min, max, unfm);
363 scan_bitmap_block(th, bm, &off, end_off + 1, min, max, unfm);
366 *start = bm * off_max + off;
371 static void _reiserfs_free_block(struct reiserfs_transaction_handle *th,
372 struct inode *inode, b_blocknr_t block,
375 struct super_block *s = th->t_super;
376 struct reiserfs_super_block *rs;
377 struct buffer_head *sbh;
378 struct reiserfs_bitmap_info *apbi;
381 BUG_ON(!th->t_trans_id);
383 PROC_INFO_INC(s, free_block);
385 rs = SB_DISK_SUPER_BLOCK(s);
386 sbh = SB_BUFFER_WITH_SB(s);
387 apbi = SB_AP_BITMAP(s);
389 get_bit_address(s, block, &nr, &offset);
391 if (nr >= sb_bmap_nr(rs)) {
392 reiserfs_warning(s, "vs-4075: reiserfs_free_block: "
393 "block %lu is out of range on %s",
394 block, reiserfs_bdevname(s));
398 reiserfs_prepare_for_journal(s, apbi[nr].bh, 1);
400 /* clear bit for the given block in bit map */
401 if (!reiserfs_test_and_clear_le_bit(offset, apbi[nr].bh->b_data)) {
402 reiserfs_warning(s, "vs-4080: reiserfs_free_block: "
403 "free_block (%s:%lu)[dev:blocknr]: bit already cleared",
404 reiserfs_bdevname(s), block);
406 apbi[nr].free_count++;
407 journal_mark_dirty(th, s, apbi[nr].bh);
409 reiserfs_prepare_for_journal(s, sbh, 1);
410 /* update super block */
411 set_sb_free_blocks(rs, sb_free_blocks(rs) + 1);
413 journal_mark_dirty(th, s, sbh);
414 if (for_unformatted) {
415 DLIMIT_FREE_BLOCK(inode, 1);
416 DQUOT_FREE_BLOCK_NODIRTY(inode, 1);
420 void reiserfs_free_block(struct reiserfs_transaction_handle *th,
421 struct inode *inode, b_blocknr_t block,
424 struct super_block *s = th->t_super;
426 BUG_ON(!th->t_trans_id);
428 RFALSE(!s, "vs-4061: trying to free block on nonexistent device");
429 RFALSE(is_reusable(s, block, 1) == 0,
430 "vs-4071: can not free such block");
431 /* mark it before we clear it, just in case */
432 journal_mark_freed(th, s, block);
433 _reiserfs_free_block(th, inode, block, for_unformatted);
436 /* preallocated blocks don't need to be run through journal_mark_freed */
437 static void reiserfs_free_prealloc_block(struct reiserfs_transaction_handle *th,
438 struct inode *inode, b_blocknr_t block)
441 "vs-4060: trying to free block on nonexistent device");
442 RFALSE(is_reusable(th->t_super, block, 1) == 0,
443 "vs-4070: can not free such block");
444 BUG_ON(!th->t_trans_id);
445 _reiserfs_free_block(th, inode, block, 1);
448 static void __discard_prealloc(struct reiserfs_transaction_handle *th,
449 struct reiserfs_inode_info *ei)
451 unsigned long save = ei->i_prealloc_block;
453 struct inode *inode = &ei->vfs_inode;
454 BUG_ON(!th->t_trans_id);
455 #ifdef CONFIG_REISERFS_CHECK
456 if (ei->i_prealloc_count < 0)
457 reiserfs_warning(th->t_super,
458 "zam-4001:%s: inode has negative prealloc blocks count.",
461 while (ei->i_prealloc_count > 0) {
462 reiserfs_free_prealloc_block(th, inode, ei->i_prealloc_block);
463 ei->i_prealloc_block++;
464 ei->i_prealloc_count--;
468 reiserfs_update_sd(th, inode);
469 ei->i_prealloc_block = save;
470 list_del_init(&(ei->i_prealloc_list));
473 /* FIXME: It should be inline function */
474 void reiserfs_discard_prealloc(struct reiserfs_transaction_handle *th,
477 struct reiserfs_inode_info *ei = REISERFS_I(inode);
478 BUG_ON(!th->t_trans_id);
479 if (ei->i_prealloc_count)
480 __discard_prealloc(th, ei);
483 void reiserfs_discard_all_prealloc(struct reiserfs_transaction_handle *th)
485 struct list_head *plist = &SB_JOURNAL(th->t_super)->j_prealloc_list;
487 BUG_ON(!th->t_trans_id);
489 while (!list_empty(plist)) {
490 struct reiserfs_inode_info *ei;
491 ei = list_entry(plist->next, struct reiserfs_inode_info,
493 #ifdef CONFIG_REISERFS_CHECK
494 if (!ei->i_prealloc_count) {
495 reiserfs_warning(th->t_super,
496 "zam-4001:%s: inode is in prealloc list but has no preallocated blocks.",
500 __discard_prealloc(th, ei);
504 void reiserfs_init_alloc_options(struct super_block *s)
506 set_bit(_ALLOC_skip_busy, &SB_ALLOC_OPTS(s));
507 set_bit(_ALLOC_dirid_groups, &SB_ALLOC_OPTS(s));
508 set_bit(_ALLOC_packing_groups, &SB_ALLOC_OPTS(s));
511 /* block allocator related options are parsed here */
512 int reiserfs_parse_alloc_options(struct super_block *s, char *options)
514 char *this_char, *value;
516 REISERFS_SB(s)->s_alloc_options.bits = 0; /* clear default settings */
518 while ((this_char = strsep(&options, ":")) != NULL) {
519 if ((value = strchr(this_char, '=')) != NULL)
522 if (!strcmp(this_char, "concentrating_formatted_nodes")) {
524 SET_OPTION(concentrating_formatted_nodes);
526 && *value) ? simple_strtoul(value, &value,
528 if (temp <= 0 || temp > 100) {
529 REISERFS_SB(s)->s_alloc_options.border = 10;
531 REISERFS_SB(s)->s_alloc_options.border =
536 if (!strcmp(this_char, "displacing_large_files")) {
537 SET_OPTION(displacing_large_files);
538 REISERFS_SB(s)->s_alloc_options.large_file_size =
540 && *value) ? simple_strtoul(value, &value, 0) : 16;
543 if (!strcmp(this_char, "displacing_new_packing_localities")) {
544 SET_OPTION(displacing_new_packing_localities);
548 if (!strcmp(this_char, "old_hashed_relocation")) {
549 SET_OPTION(old_hashed_relocation);
553 if (!strcmp(this_char, "new_hashed_relocation")) {
554 SET_OPTION(new_hashed_relocation);
558 if (!strcmp(this_char, "dirid_groups")) {
559 SET_OPTION(dirid_groups);
562 if (!strcmp(this_char, "oid_groups")) {
563 SET_OPTION(oid_groups);
566 if (!strcmp(this_char, "packing_groups")) {
567 SET_OPTION(packing_groups);
570 if (!strcmp(this_char, "hashed_formatted_nodes")) {
571 SET_OPTION(hashed_formatted_nodes);
575 if (!strcmp(this_char, "skip_busy")) {
576 SET_OPTION(skip_busy);
580 if (!strcmp(this_char, "hundredth_slices")) {
581 SET_OPTION(hundredth_slices);
585 if (!strcmp(this_char, "old_way")) {
590 if (!strcmp(this_char, "displace_based_on_dirid")) {
591 SET_OPTION(displace_based_on_dirid);
595 if (!strcmp(this_char, "preallocmin")) {
596 REISERFS_SB(s)->s_alloc_options.preallocmin =
598 && *value) ? simple_strtoul(value, &value, 0) : 4;
602 if (!strcmp(this_char, "preallocsize")) {
603 REISERFS_SB(s)->s_alloc_options.preallocsize =
605 && *value) ? simple_strtoul(value, &value,
611 reiserfs_warning(s, "zam-4001: %s : unknown option - %s",
612 __FUNCTION__, this_char);
616 reiserfs_warning(s, "allocator options = [%08x]\n", SB_ALLOC_OPTS(s));
620 static inline void new_hashed_relocation(reiserfs_blocknr_hint_t * hint)
623 if (hint->formatted_node) {
624 hash_in = (char *)&hint->key.k_dir_id;
627 //hint->search_start = hint->beg;
628 hash_in = (char *)&hint->key.k_dir_id;
630 if (TEST_OPTION(displace_based_on_dirid, hint->th->t_super))
631 hash_in = (char *)(&INODE_PKEY(hint->inode)->k_dir_id);
634 (char *)(&INODE_PKEY(hint->inode)->k_objectid);
638 hint->beg + keyed_hash(hash_in, 4) % (hint->end - hint->beg);
642 * Relocation based on dirid, hashing them into a given bitmap block
643 * files. Formatted nodes are unaffected, a seperate policy covers them
645 static void dirid_groups(reiserfs_blocknr_hint_t * hint)
650 struct super_block *sb = hint->th->t_super;
652 dirid = le32_to_cpu(INODE_PKEY(hint->inode)->k_dir_id);
653 else if (hint->formatted_node)
654 dirid = hint->key.k_dir_id;
657 bm = bmap_hash_id(sb, dirid);
658 hash = bm * (sb->s_blocksize << 3);
659 /* give a portion of the block group to metadata */
661 hash += sb->s_blocksize / 2;
662 hint->search_start = hash;
667 * Relocation based on oid, hashing them into a given bitmap block
668 * files. Formatted nodes are unaffected, a seperate policy covers them
670 static void oid_groups(reiserfs_blocknr_hint_t * hint)
678 dirid = le32_to_cpu(INODE_PKEY(hint->inode)->k_dir_id);
680 /* keep the root dir and it's first set of subdirs close to
681 * the start of the disk
684 hash = (hint->inode->i_sb->s_blocksize << 3);
686 oid = le32_to_cpu(INODE_PKEY(hint->inode)->k_objectid);
687 bm = bmap_hash_id(hint->inode->i_sb, oid);
688 hash = bm * (hint->inode->i_sb->s_blocksize << 3);
690 hint->search_start = hash;
694 /* returns 1 if it finds an indirect item and gets valid hint info
695 * from it, otherwise 0
697 static int get_left_neighbor(reiserfs_blocknr_hint_t * hint)
700 struct buffer_head *bh;
701 struct item_head *ih;
706 if (!hint->path) /* reiserfs code can call this function w/o pointer to path
707 * structure supplied; then we rely on supplied search_start */
711 bh = get_last_bh(path);
712 RFALSE(!bh, "green-4002: Illegal path specified to get_left_neighbor");
714 pos_in_item = path->pos_in_item;
715 item = get_item(path);
717 hint->search_start = bh->b_blocknr;
719 if (!hint->formatted_node && is_indirect_le_ih(ih)) {
720 /* for indirect item: go to left and look for the first non-hole entry
721 in the indirect item */
722 if (pos_in_item == I_UNFM_NUM(ih))
724 // pos_in_item = I_UNFM_NUM (ih) - 1;
725 while (pos_in_item >= 0) {
726 int t = get_block_num(item, pos_in_item);
728 hint->search_start = t;
736 /* does result value fit into specified region? */
740 /* should be, if formatted node, then try to put on first part of the device
741 specified as number of percent with mount option device, else try to put
742 on last of device. This is not to say it is good code to do so,
743 but the effect should be measured. */
744 static inline void set_border_in_hint(struct super_block *s,
745 reiserfs_blocknr_hint_t * hint)
748 SB_BLOCK_COUNT(s) / REISERFS_SB(s)->s_alloc_options.border;
750 if (hint->formatted_node)
751 hint->end = border - 1;
756 static inline void displace_large_file(reiserfs_blocknr_hint_t * hint)
758 if (TEST_OPTION(displace_based_on_dirid, hint->th->t_super))
761 keyed_hash((char *)(&INODE_PKEY(hint->inode)->k_dir_id),
762 4) % (hint->end - hint->beg);
766 keyed_hash((char *)(&INODE_PKEY(hint->inode)->k_objectid),
767 4) % (hint->end - hint->beg);
770 static inline void hash_formatted_node(reiserfs_blocknr_hint_t * hint)
775 hash_in = (char *)&hint->key.k_dir_id;
776 else if (TEST_OPTION(displace_based_on_dirid, hint->th->t_super))
777 hash_in = (char *)(&INODE_PKEY(hint->inode)->k_dir_id);
779 hash_in = (char *)(&INODE_PKEY(hint->inode)->k_objectid);
782 hint->beg + keyed_hash(hash_in, 4) % (hint->end - hint->beg);
786 this_blocknr_allocation_would_make_it_a_large_file(reiserfs_blocknr_hint_t *
789 return hint->block ==
790 REISERFS_SB(hint->th->t_super)->s_alloc_options.large_file_size;
793 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
794 static inline void displace_new_packing_locality(reiserfs_blocknr_hint_t * hint)
796 struct in_core_key *key = &hint->key;
798 hint->th->displace_new_blocks = 0;
800 hint->beg + keyed_hash((char *)(&key->k_objectid),
801 4) % (hint->end - hint->beg);
805 static inline int old_hashed_relocation(reiserfs_blocknr_hint_t * hint)
810 if (hint->formatted_node || hint->inode == NULL) {
814 hash_in = le32_to_cpu((INODE_PKEY(hint->inode))->k_dir_id);
816 hint->beg + (u32) keyed_hash(((char *)(&hash_in)),
817 4) % (hint->end - hint->beg - 1);
818 if (border > hint->search_start)
819 hint->search_start = border;
824 static inline int old_way(reiserfs_blocknr_hint_t * hint)
828 if (hint->formatted_node || hint->inode == NULL) {
834 le32_to_cpu(INODE_PKEY(hint->inode)->k_dir_id) % (hint->end -
836 if (border > hint->search_start)
837 hint->search_start = border;
842 static inline void hundredth_slices(reiserfs_blocknr_hint_t * hint)
844 struct in_core_key *key = &hint->key;
845 b_blocknr_t slice_start;
848 (keyed_hash((char *)(&key->k_dir_id), 4) % 100) * (hint->end / 100);
849 if (slice_start > hint->search_start
850 || slice_start + (hint->end / 100) <= hint->search_start) {
851 hint->search_start = slice_start;
855 static void determine_search_start(reiserfs_blocknr_hint_t * hint,
858 struct super_block *s = hint->th->t_super;
862 hint->end = SB_BLOCK_COUNT(s) - 1;
864 /* This is former border algorithm. Now with tunable border offset */
865 if (concentrating_formatted_nodes(s))
866 set_border_in_hint(s, hint);
868 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
869 /* whenever we create a new directory, we displace it. At first we will
870 hash for location, later we might look for a moderately empty place for
872 if (displacing_new_packing_localities(s)
873 && hint->th->displace_new_blocks) {
874 displace_new_packing_locality(hint);
876 /* we do not continue determine_search_start,
877 * if new packing locality is being displaced */
882 /* all persons should feel encouraged to add more special cases here and
885 if (displacing_large_files(s) && !hint->formatted_node
886 && this_blocknr_allocation_would_make_it_a_large_file(hint)) {
887 displace_large_file(hint);
891 /* if none of our special cases is relevant, use the left neighbor in the
892 tree order of the new node we are allocating for */
893 if (hint->formatted_node && TEST_OPTION(hashed_formatted_nodes, s)) {
894 hash_formatted_node(hint);
898 unfm_hint = get_left_neighbor(hint);
900 /* Mimic old block allocator behaviour, that is if VFS allowed for preallocation,
901 new blocks are displaced based on directory ID. Also, if suggested search_start
902 is less than last preallocated block, we start searching from it, assuming that
903 HDD dataflow is faster in forward direction */
904 if (TEST_OPTION(old_way, s)) {
905 if (!hint->formatted_node) {
906 if (!reiserfs_hashed_relocation(s))
908 else if (!reiserfs_no_unhashed_relocation(s))
909 old_hashed_relocation(hint);
912 && hint->search_start <
913 REISERFS_I(hint->inode)->i_prealloc_block)
915 REISERFS_I(hint->inode)->i_prealloc_block;
920 /* This is an approach proposed by Hans */
921 if (TEST_OPTION(hundredth_slices, s)
922 && !(displacing_large_files(s) && !hint->formatted_node)) {
923 hundredth_slices(hint);
927 /* old_hashed_relocation only works on unformatted */
928 if (!unfm_hint && !hint->formatted_node &&
929 TEST_OPTION(old_hashed_relocation, s)) {
930 old_hashed_relocation(hint);
932 /* new_hashed_relocation works with both formatted/unformatted nodes */
933 if ((!unfm_hint || hint->formatted_node) &&
934 TEST_OPTION(new_hashed_relocation, s)) {
935 new_hashed_relocation(hint);
937 /* dirid grouping works only on unformatted nodes */
938 if (!unfm_hint && !hint->formatted_node && TEST_OPTION(dirid_groups, s)) {
941 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
942 if (hint->formatted_node && TEST_OPTION(dirid_groups, s)) {
947 /* oid grouping works only on unformatted nodes */
948 if (!unfm_hint && !hint->formatted_node && TEST_OPTION(oid_groups, s)) {
954 static int determine_prealloc_size(reiserfs_blocknr_hint_t * hint)
956 /* make minimum size a mount option and benchmark both ways */
957 /* we preallocate blocks only for regular files, specific size */
958 /* benchmark preallocating always and see what happens */
960 hint->prealloc_size = 0;
962 if (!hint->formatted_node && hint->preallocate) {
963 if (S_ISREG(hint->inode->i_mode)
964 && hint->inode->i_size >=
965 REISERFS_SB(hint->th->t_super)->s_alloc_options.
966 preallocmin * hint->inode->i_sb->s_blocksize)
967 hint->prealloc_size =
968 REISERFS_SB(hint->th->t_super)->s_alloc_options.
974 /* XXX I know it could be merged with upper-level function;
975 but may be result function would be too complex. */
976 static inline int allocate_without_wrapping_disk(reiserfs_blocknr_hint_t * hint,
977 b_blocknr_t * new_blocknrs,
979 b_blocknr_t finish, int min,
983 int rest = amount_needed;
986 while (rest > 0 && start <= finish) {
987 nr_allocated = scan_bitmap(hint->th, &start, finish, min,
988 rest + prealloc_size,
989 !hint->formatted_node, hint->block);
991 if (nr_allocated == 0) /* no new blocks allocated, return */
994 /* fill free_blocknrs array first */
995 while (rest > 0 && nr_allocated > 0) {
996 *new_blocknrs++ = start++;
1001 /* do we have something to fill prealloc. array also ? */
1002 if (nr_allocated > 0) {
1003 /* it means prealloc_size was greater that 0 and we do preallocation */
1004 list_add(&REISERFS_I(hint->inode)->i_prealloc_list,
1005 &SB_JOURNAL(hint->th->t_super)->
1007 REISERFS_I(hint->inode)->i_prealloc_block = start;
1008 REISERFS_I(hint->inode)->i_prealloc_count =
1014 return (amount_needed - rest);
1017 static inline int blocknrs_and_prealloc_arrays_from_search_start
1018 (reiserfs_blocknr_hint_t * hint, b_blocknr_t * new_blocknrs,
1019 int amount_needed) {
1020 struct super_block *s = hint->th->t_super;
1021 b_blocknr_t start = hint->search_start;
1022 b_blocknr_t finish = SB_BLOCK_COUNT(s) - 1;
1024 int nr_allocated = 0;
1028 determine_prealloc_size(hint);
1029 if (!hint->formatted_node) {
1031 #ifdef REISERQUOTA_DEBUG
1032 reiserfs_debug(s, REISERFS_DEBUG_CODE,
1033 "reiserquota: allocating %d blocks id=%u",
1034 amount_needed, hint->inode->i_uid);
1036 quota_ret = DQUOT_ALLOC_BLOCK_NODIRTY(hint->inode,
1039 return QUOTA_EXCEEDED;
1040 if (DLIMIT_ALLOC_BLOCK(hint->inode, amount_needed)) {
1041 DQUOT_FREE_BLOCK_NODIRTY(hint->inode,
1043 return NO_DISK_SPACE;
1046 if (hint->preallocate && hint->prealloc_size) {
1047 #ifdef REISERQUOTA_DEBUG
1048 reiserfs_debug(s, REISERFS_DEBUG_CODE,
1049 "reiserquota: allocating (prealloc) %d blocks id=%u",
1050 hint->prealloc_size, hint->inode->i_uid);
1052 quota_ret = DQUOT_PREALLOC_BLOCK_NODIRTY(hint->inode,
1053 hint->prealloc_size);
1055 DLIMIT_ALLOC_BLOCK(hint->inode, hint->prealloc_size)) {
1056 DQUOT_FREE_BLOCK_NODIRTY(hint->inode,
1057 hint->prealloc_size);
1061 hint->preallocate = hint->prealloc_size = 0;
1063 /* for unformatted nodes, force large allocations */
1064 bigalloc = amount_needed;
1068 /* in bigalloc mode, nr_allocated should stay zero until
1069 * the entire allocation is filled
1071 if (unlikely(bigalloc && nr_allocated)) {
1072 reiserfs_warning(s, "bigalloc is %d, nr_allocated %d\n",
1073 bigalloc, nr_allocated);
1074 /* reset things to a sane value */
1075 bigalloc = amount_needed - nr_allocated;
1078 * try pass 0 and pass 1 looking for a nice big
1079 * contiguous allocation. Then reset and look
1080 * for anything you can find.
1082 if (passno == 2 && bigalloc) {
1087 case 0: /* Search from hint->search_start to end of disk */
1088 start = hint->search_start;
1089 finish = SB_BLOCK_COUNT(s) - 1;
1091 case 1: /* Search from hint->beg to hint->search_start */
1093 finish = hint->search_start;
1095 case 2: /* Last chance: Search from 0 to hint->beg */
1099 default: /* We've tried searching everywhere, not enough space */
1100 /* Free the blocks */
1101 if (!hint->formatted_node) {
1102 #ifdef REISERQUOTA_DEBUG
1103 reiserfs_debug(s, REISERFS_DEBUG_CODE,
1104 "reiserquota: freeing (nospace) %d blocks id=%u",
1106 hint->prealloc_size -
1108 hint->inode->i_uid);
1110 /* Free not allocated blocks */
1111 blocks = amount_needed + hint->prealloc_size - nr_allocated;
1112 DLIMIT_FREE_BLOCK(hint->inode, blocks);
1113 DQUOT_FREE_BLOCK_NODIRTY(hint->inode, blocks);
1115 while (nr_allocated--)
1116 reiserfs_free_block(hint->th, hint->inode,
1117 new_blocknrs[nr_allocated],
1118 !hint->formatted_node);
1120 return NO_DISK_SPACE;
1122 } while ((nr_allocated += allocate_without_wrapping_disk(hint,
1133 if (!hint->formatted_node &&
1134 amount_needed + hint->prealloc_size >
1135 nr_allocated + REISERFS_I(hint->inode)->i_prealloc_count) {
1136 /* Some of preallocation blocks were not allocated */
1137 #ifdef REISERQUOTA_DEBUG
1138 reiserfs_debug(s, REISERFS_DEBUG_CODE,
1139 "reiserquota: freeing (failed prealloc) %d blocks id=%u",
1140 amount_needed + hint->prealloc_size -
1142 REISERFS_I(hint->inode)->i_prealloc_count,
1143 hint->inode->i_uid);
1145 blocks = amount_needed + hint->prealloc_size - nr_allocated -
1146 REISERFS_I(hint->inode)->i_prealloc_count;
1147 DLIMIT_FREE_BLOCK(hint->inode, blocks);
1148 DQUOT_FREE_BLOCK_NODIRTY(hint->inode, blocks);
1154 /* grab new blocknrs from preallocated list */
1155 /* return amount still needed after using them */
1156 static int use_preallocated_list_if_available(reiserfs_blocknr_hint_t * hint,
1157 b_blocknr_t * new_blocknrs,
1160 struct inode *inode = hint->inode;
1162 if (REISERFS_I(inode)->i_prealloc_count > 0) {
1163 while (amount_needed) {
1165 *new_blocknrs++ = REISERFS_I(inode)->i_prealloc_block++;
1166 REISERFS_I(inode)->i_prealloc_count--;
1170 if (REISERFS_I(inode)->i_prealloc_count <= 0) {
1171 list_del(&REISERFS_I(inode)->i_prealloc_list);
1176 /* return amount still needed after using preallocated blocks */
1177 return amount_needed;
1180 int 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
1181 already reserved */ )
1183 int initial_amount_needed = amount_needed;
1185 struct super_block *s = hint->th->t_super;
1187 /* Check if there is enough space, taking into account reserved space */
1188 if (SB_FREE_BLOCKS(s) - REISERFS_SB(s)->reserved_blocks <
1189 amount_needed - reserved_by_us)
1190 return NO_DISK_SPACE;
1191 /* should this be if !hint->inode && hint->preallocate? */
1192 /* do you mean hint->formatted_node can be removed ? - Zam */
1193 /* hint->formatted_node cannot be removed because we try to access
1194 inode information here, and there is often no inode assotiated with
1195 metadata allocations - green */
1197 if (!hint->formatted_node && hint->preallocate) {
1198 amount_needed = use_preallocated_list_if_available
1199 (hint, new_blocknrs, amount_needed);
1200 if (amount_needed == 0) /* all blocknrs we need we got from
1203 new_blocknrs += (initial_amount_needed - amount_needed);
1206 /* find search start and save it in hint structure */
1207 determine_search_start(hint, amount_needed);
1208 if (hint->search_start >= SB_BLOCK_COUNT(s))
1209 hint->search_start = SB_BLOCK_COUNT(s) - 1;
1211 /* allocation itself; fill new_blocknrs and preallocation arrays */
1212 ret = blocknrs_and_prealloc_arrays_from_search_start
1213 (hint, new_blocknrs, amount_needed);
1215 /* we used prealloc. list to fill (partially) new_blocknrs array. If final allocation fails we
1216 * need to return blocks back to prealloc. list or just free them. -- Zam (I chose second
1219 if (ret != CARRY_ON) {
1220 while (amount_needed++ < initial_amount_needed) {
1221 reiserfs_free_block(hint->th, hint->inode,
1222 *(--new_blocknrs), 1);
1228 /* These 2 functions are here to provide blocks reservation to the rest of kernel */
1229 /* Reserve @blocks amount of blocks in fs pointed by @sb. Caller must make sure
1230 there are actually this much blocks on the FS available */
1231 void reiserfs_claim_blocks_to_be_allocated(struct super_block *sb, /* super block of
1235 int blocks /* How much to reserve */
1239 /* Fast case, if reservation is zero - exit immediately. */
1243 spin_lock(&REISERFS_SB(sb)->bitmap_lock);
1244 REISERFS_SB(sb)->reserved_blocks += blocks;
1245 spin_unlock(&REISERFS_SB(sb)->bitmap_lock);
1248 /* Unreserve @blocks amount of blocks in fs pointed by @sb */
1249 void reiserfs_release_claimed_blocks(struct super_block *sb, /* super block of
1253 int blocks /* How much to unreserve */
1257 /* Fast case, if unreservation is zero - exit immediately. */
1261 spin_lock(&REISERFS_SB(sb)->bitmap_lock);
1262 REISERFS_SB(sb)->reserved_blocks -= blocks;
1263 spin_unlock(&REISERFS_SB(sb)->bitmap_lock);
1264 RFALSE(REISERFS_SB(sb)->reserved_blocks < 0,
1265 "amount of blocks reserved became zero?");
1268 /* This function estimates how much pages we will be able to write to FS
1269 used for reiserfs_file_write() purposes for now. */
1270 int reiserfs_can_fit_pages(struct super_block *sb /* superblock of filesystem
1271 to estimate space */ )
1275 spin_lock(&REISERFS_SB(sb)->bitmap_lock);
1277 (SB_FREE_BLOCKS(sb) -
1278 REISERFS_SB(sb)->reserved_blocks) >> (PAGE_CACHE_SHIFT -
1279 sb->s_blocksize_bits);
1280 spin_unlock(&REISERFS_SB(sb)->bitmap_lock);
1282 return space > 0 ? space : 0;