2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
4 /* Reiserfs block (de)allocator, bitmap-based. */
6 #include <linux/config.h>
7 #include <linux/time.h>
8 #include <linux/reiserfs_fs.h>
9 #include <linux/errno.h>
10 #include <linux/buffer_head.h>
11 #include <linux/kernel.h>
12 #include <linux/pagemap.h>
13 #include <linux/reiserfs_fs_sb.h>
14 #include <linux/reiserfs_fs_i.h>
15 #include <linux/quotaops.h>
16 #include <linux/vs_dlimit.h>
18 #define PREALLOCATION_SIZE 9
20 /* different reiserfs block allocator options */
22 #define SB_ALLOC_OPTS(s) (REISERFS_SB(s)->s_alloc_options.bits)
24 #define _ALLOC_concentrating_formatted_nodes 0
25 #define _ALLOC_displacing_large_files 1
26 #define _ALLOC_displacing_new_packing_localities 2
27 #define _ALLOC_old_hashed_relocation 3
28 #define _ALLOC_new_hashed_relocation 4
29 #define _ALLOC_skip_busy 5
30 #define _ALLOC_displace_based_on_dirid 6
31 #define _ALLOC_hashed_formatted_nodes 7
32 #define _ALLOC_old_way 8
33 #define _ALLOC_hundredth_slices 9
34 #define _ALLOC_dirid_groups 10
35 #define _ALLOC_oid_groups 11
36 #define _ALLOC_packing_groups 12
38 #define concentrating_formatted_nodes(s) test_bit(_ALLOC_concentrating_formatted_nodes, &SB_ALLOC_OPTS(s))
39 #define displacing_large_files(s) test_bit(_ALLOC_displacing_large_files, &SB_ALLOC_OPTS(s))
40 #define displacing_new_packing_localities(s) test_bit(_ALLOC_displacing_new_packing_localities, &SB_ALLOC_OPTS(s))
42 #define SET_OPTION(optname) \
44 reiserfs_warning(s, "reiserfs: option \"%s\" is set", #optname); \
45 set_bit(_ALLOC_ ## optname , &SB_ALLOC_OPTS(s)); \
47 #define TEST_OPTION(optname, s) \
48 test_bit(_ALLOC_ ## optname , &SB_ALLOC_OPTS(s))
50 static inline void get_bit_address(struct super_block *s,
51 b_blocknr_t block, int *bmap_nr, int *offset)
53 /* It is in the bitmap block number equal to the block
54 * number divided by the number of bits in a block. */
55 *bmap_nr = block / (s->s_blocksize << 3);
56 /* Within that bitmap block it is located at bit offset *offset. */
57 *offset = block & ((s->s_blocksize << 3) - 1);
61 #ifdef CONFIG_REISERFS_CHECK
62 int is_reusable(struct super_block *s, b_blocknr_t block, int bit_value)
66 if (block == 0 || block >= SB_BLOCK_COUNT(s)) {
68 "vs-4010: is_reusable: block number is out of range %lu (%u)",
69 block, SB_BLOCK_COUNT(s));
73 /* it can't be one of the bitmap blocks */
74 for (i = 0; i < SB_BMAP_NR(s); i++)
75 if (block == SB_AP_BITMAP(s)[i].bh->b_blocknr) {
76 reiserfs_warning(s, "vs: 4020: is_reusable: "
77 "bitmap block %lu(%u) can't be freed or reused",
78 block, SB_BMAP_NR(s));
82 get_bit_address(s, block, &i, &j);
84 if (i >= SB_BMAP_NR(s)) {
86 "vs-4030: is_reusable: there is no so many bitmap blocks: "
87 "block=%lu, bitmap_nr=%d", block, i);
91 if ((bit_value == 0 &&
92 reiserfs_test_le_bit(j, SB_AP_BITMAP(s)[i].bh->b_data)) ||
94 reiserfs_test_le_bit(j, SB_AP_BITMAP(s)[i].bh->b_data) == 0)) {
96 "vs-4040: is_reusable: corresponding bit of block %lu does not "
97 "match required value (i==%d, j==%d) test_bit==%d",
98 block, i, j, reiserfs_test_le_bit(j,
106 if (bit_value == 0 && block == SB_ROOT_BLOCK(s)) {
108 "vs-4050: is_reusable: this is root block (%u), "
109 "it must be busy", SB_ROOT_BLOCK(s));
115 #endif /* CONFIG_REISERFS_CHECK */
117 /* searches in journal structures for a given block number (bmap, off). If block
118 is found in reiserfs journal it suggests next free block candidate to test. */
119 static inline int is_block_in_journal(struct super_block *s, int bmap, int
124 if (reiserfs_in_journal(s, bmap, off, 1, &tmp)) {
125 if (tmp) { /* hint supplied */
127 PROC_INFO_INC(s, scan_bitmap.in_journal_hint);
129 (*next) = off + 1; /* inc offset to avoid looping. */
130 PROC_INFO_INC(s, scan_bitmap.in_journal_nohint);
132 PROC_INFO_INC(s, scan_bitmap.retry);
138 /* it searches for a window of zero bits with given minimum and maximum lengths in one bitmap
140 static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
141 int bmap_n, int *beg, int boundary, int min,
144 struct super_block *s = th->t_super;
145 struct reiserfs_bitmap_info *bi = &SB_AP_BITMAP(s)[bmap_n];
149 BUG_ON(!th->t_trans_id);
151 RFALSE(bmap_n >= SB_BMAP_NR(s), "Bitmap %d is out of range (0..%d)",
152 bmap_n, SB_BMAP_NR(s) - 1);
153 PROC_INFO_INC(s, scan_bitmap.bmap);
154 /* this is unclear and lacks comments, explain how journal bitmaps
155 work here for the reader. Convey a sense of the design here. What
157 /* - I mean `a window of zero bits' as in description of this function - Zam. */
160 reiserfs_warning(s, "NULL bitmap info pointer for bitmap %d",
164 if (buffer_locked(bi->bh)) {
165 PROC_INFO_INC(s, scan_bitmap.wait);
166 __wait_on_buffer(bi->bh);
171 if (bi->free_count < min)
172 return 0; // No free blocks in this bitmap
174 /* search for a first zero bit -- beggining of a window */
175 *beg = reiserfs_find_next_zero_le_bit
176 ((unsigned long *)(bi->bh->b_data), boundary, *beg);
178 if (*beg + min > boundary) { /* search for a zero bit fails or the rest of bitmap block
179 * cannot contain a zero window of minimum size */
183 if (unfm && is_block_in_journal(s, bmap_n, *beg, beg))
185 /* first zero bit found; we check next bits */
186 for (end = *beg + 1;; end++) {
187 if (end >= *beg + max || end >= boundary
188 || reiserfs_test_le_bit(end, bi->bh->b_data)) {
192 /* finding the other end of zero bit window requires looking into journal structures (in
193 * case of searching for free blocks for unformatted nodes) */
194 if (unfm && is_block_in_journal(s, bmap_n, end, &next))
198 /* now (*beg) points to beginning of zero bits window,
199 * (end) points to one bit after the window end */
200 if (end - *beg >= min) { /* it seems we have found window of proper size */
202 reiserfs_prepare_for_journal(s, bi->bh, 1);
203 /* try to set all blocks used checking are they still free */
204 for (i = *beg; i < end; i++) {
205 /* It seems that we should not check in journal again. */
206 if (reiserfs_test_and_set_le_bit
207 (i, bi->bh->b_data)) {
208 /* bit was set by another process
209 * while we slept in prepare_for_journal() */
210 PROC_INFO_INC(s, scan_bitmap.stolen);
211 if (i >= *beg + min) { /* we can continue with smaller set of allocated blocks,
212 * if length of this set is more or equal to `min' */
216 /* otherwise we clear all bit were set ... */
218 reiserfs_test_and_clear_le_bit
220 reiserfs_restore_prepared_buffer(s,
224 /* ... and search again in current block from beginning */
228 bi->free_count -= (end - *beg);
229 journal_mark_dirty(th, s, bi->bh);
231 /* free block count calculation */
232 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s),
234 PUT_SB_FREE_BLOCKS(s, SB_FREE_BLOCKS(s) - (end - *beg));
235 journal_mark_dirty(th, s, SB_BUFFER_WITH_SB(s));
244 static int bmap_hash_id(struct super_block *s, u32 id)
246 char *hash_in = NULL;
253 hash_in = (char *)(&id);
254 hash = keyed_hash(hash_in, 4);
255 bm = hash % SB_BMAP_NR(s);
259 /* this can only be true when SB_BMAP_NR = 1 */
260 if (bm >= SB_BMAP_NR(s))
266 * hashes the id and then returns > 0 if the block group for the
267 * corresponding hash is full
269 static inline int block_group_used(struct super_block *s, u32 id)
272 bm = bmap_hash_id(s, id);
273 if (SB_AP_BITMAP(s)[bm].free_count > ((s->s_blocksize << 3) * 60 / 100)) {
280 * the packing is returned in disk byte order
282 __le32 reiserfs_choose_packing(struct inode * dir)
285 if (TEST_OPTION(packing_groups, dir->i_sb)) {
286 u32 parent_dir = le32_to_cpu(INODE_PKEY(dir)->k_dir_id);
288 * some versions of reiserfsck expect packing locality 1 to be
291 if (parent_dir == 1 || block_group_used(dir->i_sb, parent_dir))
292 packing = INODE_PKEY(dir)->k_objectid;
294 packing = INODE_PKEY(dir)->k_dir_id;
296 packing = INODE_PKEY(dir)->k_objectid;
300 /* Tries to find contiguous zero bit window (given size) in given region of
301 * bitmap and place new blocks there. Returns number of allocated blocks. */
302 static int scan_bitmap(struct reiserfs_transaction_handle *th,
303 b_blocknr_t * start, b_blocknr_t finish,
304 int min, int max, int unfm, unsigned long file_block)
306 int nr_allocated = 0;
307 struct super_block *s = th->t_super;
308 /* find every bm and bmap and bmap_nr in this file, and change them all to bitmap_blocknr
309 * - Hans, it is not a block number - Zam. */
313 int off_max = s->s_blocksize << 3;
315 BUG_ON(!th->t_trans_id);
317 PROC_INFO_INC(s, scan_bitmap.call);
318 if (SB_FREE_BLOCKS(s) <= 0)
319 return 0; // No point in looking for more free blocks
321 get_bit_address(s, *start, &bm, &off);
322 get_bit_address(s, finish, &end_bm, &end_off);
323 if (bm > SB_BMAP_NR(s))
325 if (end_bm > SB_BMAP_NR(s))
326 end_bm = SB_BMAP_NR(s);
328 /* When the bitmap is more than 10% free, anyone can allocate.
329 * When it's less than 10% free, only files that already use the
330 * bitmap are allowed. Once we pass 80% full, this restriction
333 * We do this so that files that grow later still have space close to
334 * their original allocation. This improves locality, and presumably
335 * performance as a result.
337 * This is only an allocation policy and does not make up for getting a
338 * bad hint. Decent hinting must be implemented for this to work well.
340 if (TEST_OPTION(skip_busy, s)
341 && SB_FREE_BLOCKS(s) > SB_BLOCK_COUNT(s) / 20) {
342 for (; bm < end_bm; bm++, off = 0) {
343 if ((off && (!unfm || (file_block != 0)))
344 || SB_AP_BITMAP(s)[bm].free_count >
345 (s->s_blocksize << 3) / 10)
347 scan_bitmap_block(th, bm, &off, off_max,
352 /* we know from above that start is a reasonable number */
353 get_bit_address(s, *start, &bm, &off);
356 for (; bm < end_bm; bm++, off = 0) {
358 scan_bitmap_block(th, bm, &off, off_max, min, max, unfm);
364 scan_bitmap_block(th, bm, &off, end_off + 1, min, max, unfm);
367 *start = bm * off_max + off;
372 static void _reiserfs_free_block(struct reiserfs_transaction_handle *th,
373 struct inode *inode, b_blocknr_t block,
376 struct super_block *s = th->t_super;
377 struct reiserfs_super_block *rs;
378 struct buffer_head *sbh;
379 struct reiserfs_bitmap_info *apbi;
382 BUG_ON(!th->t_trans_id);
384 PROC_INFO_INC(s, free_block);
386 rs = SB_DISK_SUPER_BLOCK(s);
387 sbh = SB_BUFFER_WITH_SB(s);
388 apbi = SB_AP_BITMAP(s);
390 get_bit_address(s, block, &nr, &offset);
392 if (nr >= sb_bmap_nr(rs)) {
393 reiserfs_warning(s, "vs-4075: reiserfs_free_block: "
394 "block %lu is out of range on %s",
395 block, reiserfs_bdevname(s));
399 reiserfs_prepare_for_journal(s, apbi[nr].bh, 1);
401 /* clear bit for the given block in bit map */
402 if (!reiserfs_test_and_clear_le_bit(offset, apbi[nr].bh->b_data)) {
403 reiserfs_warning(s, "vs-4080: reiserfs_free_block: "
404 "free_block (%s:%lu)[dev:blocknr]: bit already cleared",
405 reiserfs_bdevname(s), block);
407 apbi[nr].free_count++;
408 journal_mark_dirty(th, s, apbi[nr].bh);
410 reiserfs_prepare_for_journal(s, sbh, 1);
411 /* update super block */
412 set_sb_free_blocks(rs, sb_free_blocks(rs) + 1);
414 journal_mark_dirty(th, s, sbh);
415 if (for_unformatted) {
416 DLIMIT_FREE_BLOCK(inode, 1);
417 DQUOT_FREE_BLOCK_NODIRTY(inode, 1);
421 void reiserfs_free_block(struct reiserfs_transaction_handle *th,
422 struct inode *inode, b_blocknr_t block,
425 struct super_block *s = th->t_super;
427 BUG_ON(!th->t_trans_id);
429 RFALSE(!s, "vs-4061: trying to free block on nonexistent device");
430 RFALSE(is_reusable(s, block, 1) == 0,
431 "vs-4071: can not free such block");
432 /* mark it before we clear it, just in case */
433 journal_mark_freed(th, s, block);
434 _reiserfs_free_block(th, inode, block, for_unformatted);
437 /* preallocated blocks don't need to be run through journal_mark_freed */
438 static void reiserfs_free_prealloc_block(struct reiserfs_transaction_handle *th,
439 struct inode *inode, b_blocknr_t block)
442 "vs-4060: trying to free block on nonexistent device");
443 RFALSE(is_reusable(th->t_super, block, 1) == 0,
444 "vs-4070: can not free such block");
445 BUG_ON(!th->t_trans_id);
446 _reiserfs_free_block(th, inode, block, 1);
449 static void __discard_prealloc(struct reiserfs_transaction_handle *th,
450 struct reiserfs_inode_info *ei)
452 unsigned long save = ei->i_prealloc_block;
454 struct inode *inode = &ei->vfs_inode;
455 BUG_ON(!th->t_trans_id);
456 #ifdef CONFIG_REISERFS_CHECK
457 if (ei->i_prealloc_count < 0)
458 reiserfs_warning(th->t_super,
459 "zam-4001:%s: inode has negative prealloc blocks count.",
462 while (ei->i_prealloc_count > 0) {
463 reiserfs_free_prealloc_block(th, inode, ei->i_prealloc_block);
464 ei->i_prealloc_block++;
465 ei->i_prealloc_count--;
469 reiserfs_update_sd(th, inode);
470 ei->i_prealloc_block = save;
471 list_del_init(&(ei->i_prealloc_list));
474 /* FIXME: It should be inline function */
475 void reiserfs_discard_prealloc(struct reiserfs_transaction_handle *th,
478 struct reiserfs_inode_info *ei = REISERFS_I(inode);
479 BUG_ON(!th->t_trans_id);
480 if (ei->i_prealloc_count)
481 __discard_prealloc(th, ei);
484 void reiserfs_discard_all_prealloc(struct reiserfs_transaction_handle *th)
486 struct list_head *plist = &SB_JOURNAL(th->t_super)->j_prealloc_list;
488 BUG_ON(!th->t_trans_id);
490 while (!list_empty(plist)) {
491 struct reiserfs_inode_info *ei;
492 ei = list_entry(plist->next, struct reiserfs_inode_info,
494 #ifdef CONFIG_REISERFS_CHECK
495 if (!ei->i_prealloc_count) {
496 reiserfs_warning(th->t_super,
497 "zam-4001:%s: inode is in prealloc list but has no preallocated blocks.",
501 __discard_prealloc(th, ei);
505 void reiserfs_init_alloc_options(struct super_block *s)
507 set_bit(_ALLOC_skip_busy, &SB_ALLOC_OPTS(s));
508 set_bit(_ALLOC_dirid_groups, &SB_ALLOC_OPTS(s));
509 set_bit(_ALLOC_packing_groups, &SB_ALLOC_OPTS(s));
512 /* block allocator related options are parsed here */
513 int reiserfs_parse_alloc_options(struct super_block *s, char *options)
515 char *this_char, *value;
517 REISERFS_SB(s)->s_alloc_options.bits = 0; /* clear default settings */
519 while ((this_char = strsep(&options, ":")) != NULL) {
520 if ((value = strchr(this_char, '=')) != NULL)
523 if (!strcmp(this_char, "concentrating_formatted_nodes")) {
525 SET_OPTION(concentrating_formatted_nodes);
527 && *value) ? simple_strtoul(value, &value,
529 if (temp <= 0 || temp > 100) {
530 REISERFS_SB(s)->s_alloc_options.border = 10;
532 REISERFS_SB(s)->s_alloc_options.border =
537 if (!strcmp(this_char, "displacing_large_files")) {
538 SET_OPTION(displacing_large_files);
539 REISERFS_SB(s)->s_alloc_options.large_file_size =
541 && *value) ? simple_strtoul(value, &value, 0) : 16;
544 if (!strcmp(this_char, "displacing_new_packing_localities")) {
545 SET_OPTION(displacing_new_packing_localities);
549 if (!strcmp(this_char, "old_hashed_relocation")) {
550 SET_OPTION(old_hashed_relocation);
554 if (!strcmp(this_char, "new_hashed_relocation")) {
555 SET_OPTION(new_hashed_relocation);
559 if (!strcmp(this_char, "dirid_groups")) {
560 SET_OPTION(dirid_groups);
563 if (!strcmp(this_char, "oid_groups")) {
564 SET_OPTION(oid_groups);
567 if (!strcmp(this_char, "packing_groups")) {
568 SET_OPTION(packing_groups);
571 if (!strcmp(this_char, "hashed_formatted_nodes")) {
572 SET_OPTION(hashed_formatted_nodes);
576 if (!strcmp(this_char, "skip_busy")) {
577 SET_OPTION(skip_busy);
581 if (!strcmp(this_char, "hundredth_slices")) {
582 SET_OPTION(hundredth_slices);
586 if (!strcmp(this_char, "old_way")) {
591 if (!strcmp(this_char, "displace_based_on_dirid")) {
592 SET_OPTION(displace_based_on_dirid);
596 if (!strcmp(this_char, "preallocmin")) {
597 REISERFS_SB(s)->s_alloc_options.preallocmin =
599 && *value) ? simple_strtoul(value, &value, 0) : 4;
603 if (!strcmp(this_char, "preallocsize")) {
604 REISERFS_SB(s)->s_alloc_options.preallocsize =
606 && *value) ? simple_strtoul(value, &value,
612 reiserfs_warning(s, "zam-4001: %s : unknown option - %s",
613 __FUNCTION__, this_char);
617 reiserfs_warning(s, "allocator options = [%08x]\n", SB_ALLOC_OPTS(s));
621 static inline void new_hashed_relocation(reiserfs_blocknr_hint_t * hint)
624 if (hint->formatted_node) {
625 hash_in = (char *)&hint->key.k_dir_id;
628 //hint->search_start = hint->beg;
629 hash_in = (char *)&hint->key.k_dir_id;
631 if (TEST_OPTION(displace_based_on_dirid, hint->th->t_super))
632 hash_in = (char *)(&INODE_PKEY(hint->inode)->k_dir_id);
635 (char *)(&INODE_PKEY(hint->inode)->k_objectid);
639 hint->beg + keyed_hash(hash_in, 4) % (hint->end - hint->beg);
643 * Relocation based on dirid, hashing them into a given bitmap block
644 * files. Formatted nodes are unaffected, a seperate policy covers them
646 static void dirid_groups(reiserfs_blocknr_hint_t * hint)
651 struct super_block *sb = hint->th->t_super;
653 dirid = le32_to_cpu(INODE_PKEY(hint->inode)->k_dir_id);
654 else if (hint->formatted_node)
655 dirid = hint->key.k_dir_id;
658 bm = bmap_hash_id(sb, dirid);
659 hash = bm * (sb->s_blocksize << 3);
660 /* give a portion of the block group to metadata */
662 hash += sb->s_blocksize / 2;
663 hint->search_start = hash;
668 * Relocation based on oid, hashing them into a given bitmap block
669 * files. Formatted nodes are unaffected, a seperate policy covers them
671 static void oid_groups(reiserfs_blocknr_hint_t * hint)
679 dirid = le32_to_cpu(INODE_PKEY(hint->inode)->k_dir_id);
681 /* keep the root dir and it's first set of subdirs close to
682 * the start of the disk
685 hash = (hint->inode->i_sb->s_blocksize << 3);
687 oid = le32_to_cpu(INODE_PKEY(hint->inode)->k_objectid);
688 bm = bmap_hash_id(hint->inode->i_sb, oid);
689 hash = bm * (hint->inode->i_sb->s_blocksize << 3);
691 hint->search_start = hash;
695 /* returns 1 if it finds an indirect item and gets valid hint info
696 * from it, otherwise 0
698 static int get_left_neighbor(reiserfs_blocknr_hint_t * hint)
701 struct buffer_head *bh;
702 struct item_head *ih;
707 if (!hint->path) /* reiserfs code can call this function w/o pointer to path
708 * structure supplied; then we rely on supplied search_start */
712 bh = get_last_bh(path);
713 RFALSE(!bh, "green-4002: Illegal path specified to get_left_neighbor");
715 pos_in_item = path->pos_in_item;
716 item = get_item(path);
718 hint->search_start = bh->b_blocknr;
720 if (!hint->formatted_node && is_indirect_le_ih(ih)) {
721 /* for indirect item: go to left and look for the first non-hole entry
722 in the indirect item */
723 if (pos_in_item == I_UNFM_NUM(ih))
725 // pos_in_item = I_UNFM_NUM (ih) - 1;
726 while (pos_in_item >= 0) {
727 int t = get_block_num(item, pos_in_item);
729 hint->search_start = t;
737 /* does result value fit into specified region? */
741 /* should be, if formatted node, then try to put on first part of the device
742 specified as number of percent with mount option device, else try to put
743 on last of device. This is not to say it is good code to do so,
744 but the effect should be measured. */
745 static inline void set_border_in_hint(struct super_block *s,
746 reiserfs_blocknr_hint_t * hint)
749 SB_BLOCK_COUNT(s) / REISERFS_SB(s)->s_alloc_options.border;
751 if (hint->formatted_node)
752 hint->end = border - 1;
757 static inline void displace_large_file(reiserfs_blocknr_hint_t * hint)
759 if (TEST_OPTION(displace_based_on_dirid, hint->th->t_super))
762 keyed_hash((char *)(&INODE_PKEY(hint->inode)->k_dir_id),
763 4) % (hint->end - hint->beg);
767 keyed_hash((char *)(&INODE_PKEY(hint->inode)->k_objectid),
768 4) % (hint->end - hint->beg);
771 static inline void hash_formatted_node(reiserfs_blocknr_hint_t * hint)
776 hash_in = (char *)&hint->key.k_dir_id;
777 else if (TEST_OPTION(displace_based_on_dirid, hint->th->t_super))
778 hash_in = (char *)(&INODE_PKEY(hint->inode)->k_dir_id);
780 hash_in = (char *)(&INODE_PKEY(hint->inode)->k_objectid);
783 hint->beg + keyed_hash(hash_in, 4) % (hint->end - hint->beg);
787 this_blocknr_allocation_would_make_it_a_large_file(reiserfs_blocknr_hint_t *
790 return hint->block ==
791 REISERFS_SB(hint->th->t_super)->s_alloc_options.large_file_size;
794 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
795 static inline void displace_new_packing_locality(reiserfs_blocknr_hint_t * hint)
797 struct in_core_key *key = &hint->key;
799 hint->th->displace_new_blocks = 0;
801 hint->beg + keyed_hash((char *)(&key->k_objectid),
802 4) % (hint->end - hint->beg);
806 static inline int old_hashed_relocation(reiserfs_blocknr_hint_t * hint)
811 if (hint->formatted_node || hint->inode == NULL) {
815 hash_in = le32_to_cpu((INODE_PKEY(hint->inode))->k_dir_id);
817 hint->beg + (u32) keyed_hash(((char *)(&hash_in)),
818 4) % (hint->end - hint->beg - 1);
819 if (border > hint->search_start)
820 hint->search_start = border;
825 static inline int old_way(reiserfs_blocknr_hint_t * hint)
829 if (hint->formatted_node || hint->inode == NULL) {
835 le32_to_cpu(INODE_PKEY(hint->inode)->k_dir_id) % (hint->end -
837 if (border > hint->search_start)
838 hint->search_start = border;
843 static inline void hundredth_slices(reiserfs_blocknr_hint_t * hint)
845 struct in_core_key *key = &hint->key;
846 b_blocknr_t slice_start;
849 (keyed_hash((char *)(&key->k_dir_id), 4) % 100) * (hint->end / 100);
850 if (slice_start > hint->search_start
851 || slice_start + (hint->end / 100) <= hint->search_start) {
852 hint->search_start = slice_start;
856 static void determine_search_start(reiserfs_blocknr_hint_t * hint,
859 struct super_block *s = hint->th->t_super;
863 hint->end = SB_BLOCK_COUNT(s) - 1;
865 /* This is former border algorithm. Now with tunable border offset */
866 if (concentrating_formatted_nodes(s))
867 set_border_in_hint(s, hint);
869 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
870 /* whenever we create a new directory, we displace it. At first we will
871 hash for location, later we might look for a moderately empty place for
873 if (displacing_new_packing_localities(s)
874 && hint->th->displace_new_blocks) {
875 displace_new_packing_locality(hint);
877 /* we do not continue determine_search_start,
878 * if new packing locality is being displaced */
883 /* all persons should feel encouraged to add more special cases here and
886 if (displacing_large_files(s) && !hint->formatted_node
887 && this_blocknr_allocation_would_make_it_a_large_file(hint)) {
888 displace_large_file(hint);
892 /* if none of our special cases is relevant, use the left neighbor in the
893 tree order of the new node we are allocating for */
894 if (hint->formatted_node && TEST_OPTION(hashed_formatted_nodes, s)) {
895 hash_formatted_node(hint);
899 unfm_hint = get_left_neighbor(hint);
901 /* Mimic old block allocator behaviour, that is if VFS allowed for preallocation,
902 new blocks are displaced based on directory ID. Also, if suggested search_start
903 is less than last preallocated block, we start searching from it, assuming that
904 HDD dataflow is faster in forward direction */
905 if (TEST_OPTION(old_way, s)) {
906 if (!hint->formatted_node) {
907 if (!reiserfs_hashed_relocation(s))
909 else if (!reiserfs_no_unhashed_relocation(s))
910 old_hashed_relocation(hint);
913 && hint->search_start <
914 REISERFS_I(hint->inode)->i_prealloc_block)
916 REISERFS_I(hint->inode)->i_prealloc_block;
921 /* This is an approach proposed by Hans */
922 if (TEST_OPTION(hundredth_slices, s)
923 && !(displacing_large_files(s) && !hint->formatted_node)) {
924 hundredth_slices(hint);
928 /* old_hashed_relocation only works on unformatted */
929 if (!unfm_hint && !hint->formatted_node &&
930 TEST_OPTION(old_hashed_relocation, s)) {
931 old_hashed_relocation(hint);
933 /* new_hashed_relocation works with both formatted/unformatted nodes */
934 if ((!unfm_hint || hint->formatted_node) &&
935 TEST_OPTION(new_hashed_relocation, s)) {
936 new_hashed_relocation(hint);
938 /* dirid grouping works only on unformatted nodes */
939 if (!unfm_hint && !hint->formatted_node && TEST_OPTION(dirid_groups, s)) {
942 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
943 if (hint->formatted_node && TEST_OPTION(dirid_groups, s)) {
948 /* oid grouping works only on unformatted nodes */
949 if (!unfm_hint && !hint->formatted_node && TEST_OPTION(oid_groups, s)) {
955 static int determine_prealloc_size(reiserfs_blocknr_hint_t * hint)
957 /* make minimum size a mount option and benchmark both ways */
958 /* we preallocate blocks only for regular files, specific size */
959 /* benchmark preallocating always and see what happens */
961 hint->prealloc_size = 0;
963 if (!hint->formatted_node && hint->preallocate) {
964 if (S_ISREG(hint->inode->i_mode)
965 && hint->inode->i_size >=
966 REISERFS_SB(hint->th->t_super)->s_alloc_options.
967 preallocmin * hint->inode->i_sb->s_blocksize)
968 hint->prealloc_size =
969 REISERFS_SB(hint->th->t_super)->s_alloc_options.
975 /* XXX I know it could be merged with upper-level function;
976 but may be result function would be too complex. */
977 static inline int allocate_without_wrapping_disk(reiserfs_blocknr_hint_t * hint,
978 b_blocknr_t * new_blocknrs,
980 b_blocknr_t finish, int min,
984 int rest = amount_needed;
987 while (rest > 0 && start <= finish) {
988 nr_allocated = scan_bitmap(hint->th, &start, finish, min,
989 rest + prealloc_size,
990 !hint->formatted_node, hint->block);
992 if (nr_allocated == 0) /* no new blocks allocated, return */
995 /* fill free_blocknrs array first */
996 while (rest > 0 && nr_allocated > 0) {
997 *new_blocknrs++ = start++;
1002 /* do we have something to fill prealloc. array also ? */
1003 if (nr_allocated > 0) {
1004 /* it means prealloc_size was greater that 0 and we do preallocation */
1005 list_add(&REISERFS_I(hint->inode)->i_prealloc_list,
1006 &SB_JOURNAL(hint->th->t_super)->
1008 REISERFS_I(hint->inode)->i_prealloc_block = start;
1009 REISERFS_I(hint->inode)->i_prealloc_count =
1015 return (amount_needed - rest);
1018 static inline int blocknrs_and_prealloc_arrays_from_search_start
1019 (reiserfs_blocknr_hint_t * hint, b_blocknr_t * new_blocknrs,
1020 int amount_needed) {
1021 struct super_block *s = hint->th->t_super;
1022 b_blocknr_t start = hint->search_start;
1023 b_blocknr_t finish = SB_BLOCK_COUNT(s) - 1;
1025 int nr_allocated = 0;
1029 determine_prealloc_size(hint);
1030 if (!hint->formatted_node) {
1032 #ifdef REISERQUOTA_DEBUG
1033 reiserfs_debug(s, REISERFS_DEBUG_CODE,
1034 "reiserquota: allocating %d blocks id=%u",
1035 amount_needed, hint->inode->i_uid);
1037 quota_ret = DQUOT_ALLOC_BLOCK_NODIRTY(hint->inode,
1040 return QUOTA_EXCEEDED;
1041 if (DLIMIT_ALLOC_BLOCK(hint->inode, amount_needed)) {
1042 DQUOT_FREE_BLOCK_NODIRTY(hint->inode,
1044 return NO_DISK_SPACE;
1047 if (hint->preallocate && hint->prealloc_size) {
1048 #ifdef REISERQUOTA_DEBUG
1049 reiserfs_debug(s, REISERFS_DEBUG_CODE,
1050 "reiserquota: allocating (prealloc) %d blocks id=%u",
1051 hint->prealloc_size, hint->inode->i_uid);
1053 quota_ret = DQUOT_PREALLOC_BLOCK_NODIRTY(hint->inode,
1054 hint->prealloc_size);
1056 DLIMIT_ALLOC_BLOCK(hint->inode, hint->prealloc_size)) {
1057 DQUOT_FREE_BLOCK_NODIRTY(hint->inode,
1058 hint->prealloc_size);
1062 hint->preallocate = hint->prealloc_size = 0;
1064 /* for unformatted nodes, force large allocations */
1065 bigalloc = amount_needed;
1069 /* in bigalloc mode, nr_allocated should stay zero until
1070 * the entire allocation is filled
1072 if (unlikely(bigalloc && nr_allocated)) {
1073 reiserfs_warning(s, "bigalloc is %d, nr_allocated %d\n",
1074 bigalloc, nr_allocated);
1075 /* reset things to a sane value */
1076 bigalloc = amount_needed - nr_allocated;
1079 * try pass 0 and pass 1 looking for a nice big
1080 * contiguous allocation. Then reset and look
1081 * for anything you can find.
1083 if (passno == 2 && bigalloc) {
1088 case 0: /* Search from hint->search_start to end of disk */
1089 start = hint->search_start;
1090 finish = SB_BLOCK_COUNT(s) - 1;
1092 case 1: /* Search from hint->beg to hint->search_start */
1094 finish = hint->search_start;
1096 case 2: /* Last chance: Search from 0 to hint->beg */
1100 default: /* We've tried searching everywhere, not enough space */
1101 /* Free the blocks */
1102 if (!hint->formatted_node) {
1103 #ifdef REISERQUOTA_DEBUG
1104 reiserfs_debug(s, REISERFS_DEBUG_CODE,
1105 "reiserquota: freeing (nospace) %d blocks id=%u",
1107 hint->prealloc_size -
1109 hint->inode->i_uid);
1111 /* Free not allocated blocks */
1112 blocks = amount_needed + hint->prealloc_size - nr_allocated;
1113 DLIMIT_FREE_BLOCK(hint->inode, blocks);
1114 DQUOT_FREE_BLOCK_NODIRTY(hint->inode, blocks);
1116 while (nr_allocated--)
1117 reiserfs_free_block(hint->th, hint->inode,
1118 new_blocknrs[nr_allocated],
1119 !hint->formatted_node);
1121 return NO_DISK_SPACE;
1123 } while ((nr_allocated += allocate_without_wrapping_disk(hint,
1134 if (!hint->formatted_node &&
1135 amount_needed + hint->prealloc_size >
1136 nr_allocated + REISERFS_I(hint->inode)->i_prealloc_count) {
1137 /* Some of preallocation blocks were not allocated */
1138 #ifdef REISERQUOTA_DEBUG
1139 reiserfs_debug(s, REISERFS_DEBUG_CODE,
1140 "reiserquota: freeing (failed prealloc) %d blocks id=%u",
1141 amount_needed + hint->prealloc_size -
1143 REISERFS_I(hint->inode)->i_prealloc_count,
1144 hint->inode->i_uid);
1146 blocks = amount_needed + hint->prealloc_size - nr_allocated -
1147 REISERFS_I(hint->inode)->i_prealloc_count;
1148 DLIMIT_FREE_BLOCK(hint->inode, blocks);
1149 DQUOT_FREE_BLOCK_NODIRTY(hint->inode, blocks);
1155 /* grab new blocknrs from preallocated list */
1156 /* return amount still needed after using them */
1157 static int use_preallocated_list_if_available(reiserfs_blocknr_hint_t * hint,
1158 b_blocknr_t * new_blocknrs,
1161 struct inode *inode = hint->inode;
1163 if (REISERFS_I(inode)->i_prealloc_count > 0) {
1164 while (amount_needed) {
1166 *new_blocknrs++ = REISERFS_I(inode)->i_prealloc_block++;
1167 REISERFS_I(inode)->i_prealloc_count--;
1171 if (REISERFS_I(inode)->i_prealloc_count <= 0) {
1172 list_del(&REISERFS_I(inode)->i_prealloc_list);
1177 /* return amount still needed after using preallocated blocks */
1178 return amount_needed;
1181 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
1182 already reserved */ )
1184 int initial_amount_needed = amount_needed;
1186 struct super_block *s = hint->th->t_super;
1188 /* Check if there is enough space, taking into account reserved space */
1189 if (SB_FREE_BLOCKS(s) - REISERFS_SB(s)->reserved_blocks <
1190 amount_needed - reserved_by_us)
1191 return NO_DISK_SPACE;
1192 /* should this be if !hint->inode && hint->preallocate? */
1193 /* do you mean hint->formatted_node can be removed ? - Zam */
1194 /* hint->formatted_node cannot be removed because we try to access
1195 inode information here, and there is often no inode assotiated with
1196 metadata allocations - green */
1198 if (!hint->formatted_node && hint->preallocate) {
1199 amount_needed = use_preallocated_list_if_available
1200 (hint, new_blocknrs, amount_needed);
1201 if (amount_needed == 0) /* all blocknrs we need we got from
1204 new_blocknrs += (initial_amount_needed - amount_needed);
1207 /* find search start and save it in hint structure */
1208 determine_search_start(hint, amount_needed);
1209 if (hint->search_start >= SB_BLOCK_COUNT(s))
1210 hint->search_start = SB_BLOCK_COUNT(s) - 1;
1212 /* allocation itself; fill new_blocknrs and preallocation arrays */
1213 ret = blocknrs_and_prealloc_arrays_from_search_start
1214 (hint, new_blocknrs, amount_needed);
1216 /* we used prealloc. list to fill (partially) new_blocknrs array. If final allocation fails we
1217 * need to return blocks back to prealloc. list or just free them. -- Zam (I chose second
1220 if (ret != CARRY_ON) {
1221 while (amount_needed++ < initial_amount_needed) {
1222 reiserfs_free_block(hint->th, hint->inode,
1223 *(--new_blocknrs), 1);
1229 /* These 2 functions are here to provide blocks reservation to the rest of kernel */
1230 /* Reserve @blocks amount of blocks in fs pointed by @sb. Caller must make sure
1231 there are actually this much blocks on the FS available */
1232 void reiserfs_claim_blocks_to_be_allocated(struct super_block *sb, /* super block of
1236 int blocks /* How much to reserve */
1240 /* Fast case, if reservation is zero - exit immediately. */
1244 spin_lock(&REISERFS_SB(sb)->bitmap_lock);
1245 REISERFS_SB(sb)->reserved_blocks += blocks;
1246 spin_unlock(&REISERFS_SB(sb)->bitmap_lock);
1249 /* Unreserve @blocks amount of blocks in fs pointed by @sb */
1250 void reiserfs_release_claimed_blocks(struct super_block *sb, /* super block of
1254 int blocks /* How much to unreserve */
1258 /* Fast case, if unreservation is zero - exit immediately. */
1262 spin_lock(&REISERFS_SB(sb)->bitmap_lock);
1263 REISERFS_SB(sb)->reserved_blocks -= blocks;
1264 spin_unlock(&REISERFS_SB(sb)->bitmap_lock);
1265 RFALSE(REISERFS_SB(sb)->reserved_blocks < 0,
1266 "amount of blocks reserved became zero?");
1269 /* This function estimates how much pages we will be able to write to FS
1270 used for reiserfs_file_write() purposes for now. */
1271 int reiserfs_can_fit_pages(struct super_block *sb /* superblock of filesystem
1272 to estimate space */ )
1276 spin_lock(&REISERFS_SB(sb)->bitmap_lock);
1278 (SB_FREE_BLOCKS(sb) -
1279 REISERFS_SB(sb)->reserved_blocks) >> (PAGE_CACHE_SHIFT -
1280 sb->s_blocksize_bits);
1281 spin_unlock(&REISERFS_SB(sb)->bitmap_lock);
1283 return space > 0 ? space : 0;