fs/reiserfs/bitmap.c

   1 /*
   2  * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
   3  */
   4 /* Reiserfs block (de)allocator, bitmap-based. */
   5
   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/vmalloc.h>
  13 #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
  49 static inline void get_bit_address(struct super_block *s,
  50                                    b_blocknr_t block, int *bmap_nr, int *offset)
  51 {
  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_bits + 3);
  55         /* Within that bitmap block it is located at bit offset *offset. */
  56         *offset = block & ((s->s_blocksize << 3) - 1);
  57 }
  58
  59 #ifdef CONFIG_REISERFS_CHECK
  60 int is_reusable(struct super_block *s, b_blocknr_t block, int bit_value)
  61 {
  62         int bmap, offset;
  63
  64         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;
  69         }
  70
  71         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) {
  86                         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                 }
  91         }
  92
  93         if (bmap >= SB_BMAP_NR(s)) {
  94                 reiserfs_warning(s,
  95                                  "vs-4030: is_reusable: there is no so many bitmap blocks: "
  96                                  "block=%lu, bitmap_nr=%d", block, bmap);
  97                 return 0;
  98         }
  99
 100         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;
 108 }
 109 #endif                          /* CONFIG_REISERFS_CHECK */
 110
 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. */
 113 static inline int is_block_in_journal(struct super_block *s, int bmap, int
 114                                       off, int *next)
 115 {
 116         b_blocknr_t tmp;
 117
 118         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;
 128         }
 129         return 0;
 130 }
 131
 132 /* it searches for a window of zero bits with given minimum and maximum lengths in one bitmap
 133  * block; */
 134 static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
 135                              int bmap_n, int *beg, int boundary, int min,
 136                              int max, int unfm)
 137 {
 138         struct super_block *s = th->t_super;
 139         struct reiserfs_bitmap_info *bi = &SB_AP_BITMAP(s)[bmap_n];
 140         struct buffer_head *bh;
 141         int end, next;
 142         int org = *beg;
 143
 144         BUG_ON(!th->t_trans_id);
 145
 146         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);
 149 /* 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. */
 153
 154         if (!bi) {
 155                 reiserfs_warning(s, "NULL bitmap info pointer for bitmap %d",
 156                                  bmap_n);
 157                 return 0;
 158         }
 159
 160         bh = reiserfs_read_bitmap_block(s, bmap_n);
 161         if (bh == NULL)
 162                 return 0;
 163
 164         while (1) {
 165               cont:
 166                 if (bi->free_count < min) {
 167                         brelse(bh);
 168                         return 0;       // No free blocks in this bitmap
 169                 }
 170
 171                 /* search for a first zero bit -- beggining of a window */
 172                 *beg = reiserfs_find_next_zero_le_bit
 173                     ((unsigned long *)(bh->b_data), boundary, *beg);
 174
 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 */
 177                         brelse(bh);
 178                         return 0;
 179                 }
 180
 181                 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
 186                             || reiserfs_test_le_bit(end, bh->b_data)) {
 187                                 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                 }
 195
 196                 /* 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;
 200                         reiserfs_prepare_for_journal(s, bh, 1);
 201                         /* 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
 205                                     (i, bh->b_data)) {
 206                                         /* 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
 217                                                     (i, bh->b_data);
 218                                         reiserfs_restore_prepared_buffer(s, bh);
 219                                         *beg = org;
 220                                         /* ... and search again in current block from beginning */
 221                                         goto cont;
 222                                 }
 223                         }
 224                         bi->free_count -= (end - *beg);
 225                         journal_mark_dirty(th, s, bh);
 226                         brelse(bh);
 227
 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                 }
 238         }
 239 }
 240
 241 static int bmap_hash_id(struct super_block *s, u32 id)
 242 {
 243         char *hash_in = NULL;
 244         unsigned long hash;
 245         unsigned bm;
 246
 247         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;
 260 }
 261
 262 /*
 263  * hashes the id and then returns > 0 if the block group for the
 264  * corresponding hash is full
 265  */
 266 static inline int block_group_used(struct super_block *s, u32 id)
 267 {
 268         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)) {
 282                 return 0;
 283         }
 284         return 1;
 285 }
 286
 287 /*
 288  * the packing is returned in disk byte order
 289  */
 290 __le32 reiserfs_choose_packing(struct inode * dir)
 291 {
 292         __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;
 306 }
 307
 308 /* 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. */
 310 static 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)
 313 {
 314         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. */
 318
 319         int bm, off;
 320         int end_bm, end_off;
 321         int off_max = s->s_blocksize << 3;
 322
 323         BUG_ON(!th->t_trans_id);
 324
 325         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
 328
 329         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);
 335
 336         /* 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         }
 363
 364         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         }
 370
 371         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;
 377
 378 }
 379
 380 static void _reiserfs_free_block(struct reiserfs_transaction_handle *th,
 381                                  struct inode *inode, b_blocknr_t block,
 382                                  int for_unformatted)
 383 {
 384         struct super_block *s = th->t_super;
 385         struct reiserfs_super_block *rs;
 386         struct buffer_head *sbh, *bmbh;
 387         struct reiserfs_bitmap_info *apbi;
 388         int nr, offset;
 389
 390         BUG_ON(!th->t_trans_id);
 391
 392         PROC_INFO_INC(s, free_block);
 393
 394         rs = SB_DISK_SUPER_BLOCK(s);
 395         sbh = SB_BUFFER_WITH_SB(s);
 396         apbi = SB_AP_BITMAP(s);
 397
 398         get_bit_address(s, block, &nr, &offset);
 399
 400         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         }
 406
 407         bmbh = reiserfs_read_bitmap_block(s, nr);
 408         if (!bmbh)
 409                 return;
 410
 411         reiserfs_prepare_for_journal(s, bmbh, 1);
 412
 413         /* clear bit for the given block in bit map */
 414         if (!reiserfs_test_and_clear_le_bit(offset, bmbh->b_data)) {
 415                 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++;
 420         journal_mark_dirty(th, s, bmbh);
 421         brelse(bmbh);
 422
 423         reiserfs_prepare_for_journal(s, sbh, 1);
 424         /* update super block */
 425         set_sb_free_blocks(rs, sb_free_blocks(rs) + 1);
 426
 427         journal_mark_dirty(th, s, sbh);
 428         if (for_unformatted)
 429                 DQUOT_FREE_BLOCK_NODIRTY(inode, 1);
 430 }
 431
 432 void reiserfs_free_block(struct reiserfs_transaction_handle *th,
 433                          struct inode *inode, b_blocknr_t block,
 434                          int for_unformatted)
 435 {
 436         struct super_block *s = th->t_super;
 437
 438         BUG_ON(!th->t_trans_id);
 439
 440         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);
 446 }
 447
 448 /* preallocated blocks don't need to be run through journal_mark_freed */
 449 static 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);
 458 }
 459
 460 static void __discard_prealloc(struct reiserfs_transaction_handle *th,
 461                                struct reiserfs_inode_info *ei)
 462 {
 463         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);
 467 #ifdef CONFIG_REISERFS_CHECK
 468         if (ei->i_prealloc_count < 0)
 469                 reiserfs_warning(th->t_super,
 470                                  "zam-4001:%s: inode has negative prealloc blocks count.",
 471                                  __FUNCTION__);
 472 #endif
 473         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));
 483 }
 484
 485 /* FIXME: It should be inline function */
 486 void reiserfs_discard_prealloc(struct reiserfs_transaction_handle *th,
 487                                struct inode *inode)
 488 {
 489         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);
 493 }
 494
 495 void reiserfs_discard_all_prealloc(struct reiserfs_transaction_handle *th)
 496 {
 497         struct list_head *plist = &SB_JOURNAL(th->t_super)->j_prealloc_list;
 498
 499         BUG_ON(!th->t_trans_id);
 500
 501         while (!list_empty(plist)) {
 502                 struct reiserfs_inode_info *ei;
 503                 ei = list_entry(plist->next, struct reiserfs_inode_info,
 504                                 i_prealloc_list);
 505 #ifdef CONFIG_REISERFS_CHECK
 506                 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                 }
 511 #endif
 512                 __discard_prealloc(th, ei);
 513         }
 514 }
 515
 516 void reiserfs_init_alloc_options(struct super_block *s)
 517 {
 518         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));
 521 }
 522
 523 /* block allocator related options are parsed here */
 524 int reiserfs_parse_alloc_options(struct super_block *s, char *options)
 525 {
 526         char *this_char, *value;
 527
 528         REISERFS_SB(s)->s_alloc_options.bits = 0;       /* clear default settings */
 529
 530         while ((this_char = strsep(&options, ":")) != NULL) {
 531                 if ((value = strchr(this_char, '=')) != NULL)
 532                         *value++ = 0;
 533
 534                 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                 };
 559
 560                 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;
 626         }
 627
 628         reiserfs_warning(s, "allocator options = [%08x]\n", SB_ALLOC_OPTS(s));
 629         return 0;
 630 }
 631
 632 static 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);
 651 }
 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  */
 657 static void dirid_groups(reiserfs_blocknr_hint_t * hint)
 658 {
 659         unsigned long hash;
 660         __u32 dirid = 0;
 661         int bm = 0;
 662         struct super_block *sb = hint->th->t_super;
 663         if (hint->inode)
 664                 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         }
 676 }
 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  */
 682 static void oid_groups(reiserfs_blocknr_hint_t * hint)
 683 {
 684         if (hint->inode) {
 685                 unsigned long hash;
 686                 __u32 oid;
 687                 __u32 dirid;
 688                 int bm;
 689
 690                 dirid = le32_to_cpu(INODE_PKEY(hint->inode)->k_dir_id);
 691
 692                 /* 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;
 703         }
 704 }
 705
 706 /* returns 1 if it finds an indirect item and gets valid hint info
 707  * from it, otherwise 0
 708  */
 709 static int get_left_neighbor(reiserfs_blocknr_hint_t * hint)
 710 {
 711         struct path *path;
 712         struct buffer_head *bh;
 713         struct item_head *ih;
 714         int pos_in_item;
 715         __le32 *item;
 716         int ret = 0;
 717
 718         if (!hint->path)        /* reiserfs code can call this function w/o pointer to path
 719                                  * structure supplied; then we rely on supplied search_start */
 720                 return 0;
 721
 722         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);
 728
 729         hint->search_start = bh->b_blocknr;
 730
 731         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                 }
 746         }
 747
 748         /* does result value fit into specified region? */
 749         return ret;
 750 }
 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.  */
 756 static inline void set_border_in_hint(struct super_block *s,
 757                                       reiserfs_blocknr_hint_t * hint)
 758 {
 759         b_blocknr_t border =
 760             SB_BLOCK_COUNT(s) / REISERFS_SB(s)->s_alloc_options.border;
 761
 762         if (hint->formatted_node)
 763                 hint->end = border - 1;
 764         else
 765                 hint->beg = border;
 766 }
 767
 768 static inline void displace_large_file(reiserfs_blocknr_hint_t * hint)
 769 {
 770         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);
 780 }
 781
 782 static inline void hash_formatted_node(reiserfs_blocknr_hint_t * hint)
 783 {
 784         char *hash_in;
 785
 786         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);
 792
 793         hint->search_start =
 794             hint->beg + keyed_hash(hash_in, 4) % (hint->end - hint->beg);
 795 }
 796
 797 static inline int
 798 this_blocknr_allocation_would_make_it_a_large_file(reiserfs_blocknr_hint_t *
 799                                                    hint)
 800 {
 801         return hint->block ==
 802             REISERFS_SB(hint->th->t_super)->s_alloc_options.large_file_size;
 803 }
 804
 805 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
 806 static inline void displace_new_packing_locality(reiserfs_blocknr_hint_t * hint)
 807 {
 808         struct in_core_key *key = &hint->key;
 809
 810         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);
 814 }
 815 #endif
 816
 817 static inline int old_hashed_relocation(reiserfs_blocknr_hint_t * hint)
 818 {
 819         b_blocknr_t border;
 820         u32 hash_in;
 821
 822         if (hint->formatted_node || hint->inode == NULL) {
 823                 return 0;
 824         }
 825
 826         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;
 832
 833         return 1;
 834 }
 835
 836 static 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
 854 static 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
 867 static 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)) {
 942                 old_hashed_relocation(hint);
 943         }
 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
 958
 959         /* oid grouping works only on unformatted nodes */
 960         if (!unfm_hint && !hint->formatted_node && TEST_OPTION(oid_groups, s)) {
 961                 oid_groups(hint);
 962         }
 963         return;
 964 }
 965
 966 static int determine_prealloc_size(reiserfs_blocknr_hint_t * hint)
 967 {
 968         /* 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 */
 971
 972         hint->prealloc_size = 0;
 973
 974         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;
 984 }
 985
 986 /* XXX I know it could be merged with upper-level function;
 987    but may be result function would be too complex. */
 988 static 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)
 994 {
 995         int rest = amount_needed;
 996         int nr_allocated;
 997
 998         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                 }
1024         }
1025
1026         return (amount_needed - rest);
1027 }
1028
1029 static inline int blocknrs_and_prealloc_arrays_from_search_start
1030     (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;
1037
1038         determine_prealloc_size(hint);
1039         if (!hint->formatted_node) {
1040                 int quota_ret;
1041 #ifdef REISERQUOTA_DEBUG
1042                 reiserfs_debug(s, REISERFS_DEBUG_CODE,
1043                                "reiserquota: allocating %d blocks id=%u",
1044                                amount_needed, hint->inode->i_uid);
1045 #endif
1046                 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) {
1051 #ifdef REISERQUOTA_DEBUG
1052                         reiserfs_debug(s, REISERFS_DEBUG_CODE,
1053                                        "reiserquota: allocating (prealloc) %d blocks id=%u",
1054                                        hint->prealloc_size, hint->inode->i_uid);
1055 #endif
1056                         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 */
1063         }
1064
1065         do {
1066                 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) {
1082 #ifdef REISERQUOTA_DEBUG
1083                                 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);
1089 #endif
1090                                 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);
1096
1097                         return NO_DISK_SPACE;
1098                 }
1099         } while ((nr_allocated += allocate_without_wrapping_disk(hint,
1100                                                                  new_blocknrs +
1101                                                                  nr_allocated,
1102                                                                  start, finish,
1103                                                                  1,
1104                                                                  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 */
1113 #ifdef REISERQUOTA_DEBUG
1114                 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);
1120 #endif
1121                 DQUOT_FREE_BLOCK_NODIRTY(hint->inode, amount_needed +
1122                                          hint->prealloc_size - nr_allocated -
1123                                          REISERFS_I(hint->inode)->
1124                                          i_prealloc_count);
1125         }
1126
1127         return CARRY_ON;
1128 }
1129
1130 /* grab new blocknrs from preallocated list */
1131 /* return amount still needed after using them */
1132 static int use_preallocated_list_if_available(reiserfs_blocknr_hint_t * hint,
1133                                               b_blocknr_t * new_blocknrs,
1134                                               int amount_needed)
1135 {
1136         struct inode *inode = hint->inode;
1137
1138         if (REISERFS_I(inode)->i_prealloc_count > 0) {
1139                 while (amount_needed) {
1140
1141                         *new_blocknrs++ = REISERFS_I(inode)->i_prealloc_block++;
1142                         REISERFS_I(inode)->i_prealloc_count--;
1143
1144                         amount_needed--;
1145
1146                         if (REISERFS_I(inode)->i_prealloc_count <= 0) {
1147                                 list_del(&REISERFS_I(inode)->i_prealloc_list);
1148                                 break;
1149                         }
1150                 }
1151         }
1152         /* return amount still needed after using preallocated blocks */
1153         return amount_needed;
1154 }
1155
1156 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
1157                                                                                                                                            already reserved */ )
1158 {
1159         int initial_amount_needed = amount_needed;
1160         int ret;
1161         struct super_block *s = hint->th->t_super;
1162
1163         /* 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 */
1172
1173         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);
1180         }
1181
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;
1202 }
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 */
1207 void 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     )
1213 {
1214
1215         /* Fast case, if reservation is zero - exit immediately. */
1216         if (!blocks)
1217                 return;
1218
1219         spin_lock(&REISERFS_SB(sb)->bitmap_lock);
1220         REISERFS_SB(sb)->reserved_blocks += blocks;
1221         spin_unlock(&REISERFS_SB(sb)->bitmap_lock);
1222 }
1223
1224 /* Unreserve @blocks amount of blocks in fs pointed by @sb */
1225 void 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     )
1231 {
1232
1233         /* Fast case, if unreservation is zero - exit immediately. */
1234         if (!blocks)
1235                 return;
1236
1237         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?");
1242 }
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. */
1246 int reiserfs_can_fit_pages(struct super_block *sb       /* superblock of filesystem
1247                                                            to estimate space */ )
1248 {
1249         int space;
1250
1251         spin_lock(&REISERFS_SB(sb)->bitmap_lock);
1252         space =
1253             (SB_FREE_BLOCKS(sb) -
1254              REISERFS_SB(sb)->reserved_blocks) >> (PAGE_CACHE_SHIFT -
1255                                                    sb->s_blocksize_bits);
1256         spin_unlock(&REISERFS_SB(sb)->bitmap_lock);
1257
1258         return space > 0 ? space : 0;
1259 }
1260
1261 void 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
1290 struct 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;
1294         struct reiserfs_bitmap_info *info = SB_AP_BITMAP(sb) + bitmap;
1295         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
1305         bh = sb_bread(sb, block);
1306         if (bh == NULL)
1307                 reiserfs_warning(sb, "sh-2029: %s: bitmap block (#%u) "
1308                                  "reading failed", __FUNCTION__, block);
1309         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         }
1320
1321         return bh;
1322 }
1323
1324 int reiserfs_init_bitmap_cache(struct super_block *sb)
1325 {
1326         struct reiserfs_bitmap_info *bitmap;
1327
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
1334         SB_AP_BITMAP(sb) = bitmap;
1335
1336         return 0;
1337 }
1338
1339 void 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 }