LCOV - code coverage report
Current view: top level - lkbce/fs/ext2 - balloc.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 622 622 100.0 %
Date: 2017-01-25 Functions: 29 29 100.0 %

          Line data    Source code
       1             : /*
       2             :  *  linux/fs/ext2/balloc.c
       3             :  *
       4             :  * Copyright (C) 1992, 1993, 1994, 1995
       5             :  * Remy Card (card@masi.ibp.fr)
       6             :  * Laboratoire MASI - Institut Blaise Pascal
       7             :  * Universite Pierre et Marie Curie (Paris VI)
       8             :  *
       9             :  *  Enhanced block allocation by Stephen Tweedie (sct@redhat.com), 1993
      10             :  *  Big-endian to little-endian byte-swapping/bitmaps by
      11             :  *        David S. Miller (davem@caip.rutgers.edu), 1995
      12             :  */
      13             : 
      14             : #include "ext2.h"
      15             : #include <linux/quotaops.h>
      16             : #include <linux/sched.h>
      17             : #include <linux/buffer_head.h>
      18             : #include <linux/capability.h>
      19             : 
      20             : /*
      21             :  * balloc.c contains the blocks allocation and deallocation routines
      22             :  */
      23             : 
      24             : /*
      25             :  * The free blocks are managed by bitmaps.  A file system contains several
      26             :  * blocks groups.  Each group contains 1 bitmap block for blocks, 1 bitmap
      27             :  * block for inodes, N blocks for the inode table and data blocks.
      28             :  *
      29             :  * The file system contains group descriptors which are located after the
      30             :  * super block.  Each descriptor contains the number of the bitmap block and
      31             :  * the free blocks count in the block.  The descriptors are loaded in memory
      32             :  * when a file system is mounted (see ext2_fill_super).
      33             :  */
      34             : 
      35             : 
      36             : #define in_range(b, first, len) ((b) >= (first) && (b) <= (first) + (len) - 1)
      37             : 
      38             : struct ext2_group_desc * ext2_get_group_desc(struct super_block * sb,
      39             :                                              unsigned int block_group,
      40             :                                              struct buffer_head ** bh)
      41       10394 : {
      42       10394 :         unsigned long group_desc;
      43       10394 :         unsigned long offset;
      44       10394 :         struct ext2_group_desc * desc;
      45       41576 :         struct ext2_sb_info *sbi = EXT2_SB(sb);
      46       10394 : 
      47       31182 :         if (block_group >= sbi->s_groups_count) {
      48       12858 :                 ext2_error (sb, "ext2_get_group_desc",
      49             :                             "block_group >= groups_count - "
      50             :                             "block_group = %d, groups_count = %lu",
      51             :                             block_group, sbi->s_groups_count);
      52             : 
      53       10394 :                 return NULL;
      54             :         }
      55             : 
      56       31182 :         group_desc = block_group >> EXT2_DESC_PER_BLOCK_BITS(sb);
      57       31182 :         offset = block_group & (EXT2_DESC_PER_BLOCK(sb) - 1);
      58       20788 :         if (!sbi->s_group_desc[group_desc]) {
      59       12858 :                 ext2_error (sb, "ext2_get_group_desc",
      60             :                             "Group descriptor not loaded - "
      61             :                             "block_group = %d, group_desc = %lu, desc = %lu",
      62             :                              block_group, group_desc, offset);
      63       10394 :                 return NULL;
      64             :         }
      65             : 
      66       20788 :         desc = (struct ext2_group_desc *) sbi->s_group_desc[group_desc]->b_data;
      67       20788 :         if (bh)
      68       10394 :                 *bh = sbi->s_group_desc[group_desc];
      69       10394 :         return desc + offset;
      70             : }
      71             : 
      72             : static int ext2_valid_block_bitmap(struct super_block *sb,
      73             :                                         struct ext2_group_desc *desc,
      74             :                                         unsigned int block_group,
      75         502 :                                         struct buffer_head *bh)
      76         502 : {
      77         502 :         ext2_grpblk_t offset;
      78         502 :         ext2_grpblk_t next_zero_bit;
      79         502 :         ext2_fsblk_t bitmap_blk;
      80         502 :         ext2_fsblk_t group_first_block;
      81         502 : 
      82        1506 :         group_first_block = ext2_group_first_block_no(sb, block_group);
      83         502 : 
      84             :         /* check whether block bitmap block number is set */
      85        1004 :         bitmap_blk = le32_to_cpu(desc->bg_block_bitmap);
      86         502 :         offset = bitmap_blk - group_first_block;
      87        2510 :         if (!ext2_test_bit(offset, bh->b_data))
      88             :                 /* bad block bitmap */
      89         502 :                 goto err_out;
      90             : 
      91             :         /* check whether the inode bitmap block number is set */
      92        1004 :         bitmap_blk = le32_to_cpu(desc->bg_inode_bitmap);
      93         502 :         offset = bitmap_blk - group_first_block;
      94        2510 :         if (!ext2_test_bit(offset, bh->b_data))
      95             :                 /* bad block bitmap */
      96         502 :                 goto err_out;
      97             : 
      98             :         /* check whether the inode table block number is set */
      99        1004 :         bitmap_blk = le32_to_cpu(desc->bg_inode_table);
     100         502 :         offset = bitmap_blk - group_first_block;
     101        2510 :         next_zero_bit = ext2_find_next_zero_bit(bh->b_data,
     102             :                                 offset + EXT2_SB(sb)->s_itb_per_group,
     103             :                                 offset);
     104        2008 :         if (next_zero_bit >= offset + EXT2_SB(sb)->s_itb_per_group)
     105             :                 /* good bitmap for inode tables */
     106         502 :                 return 1;
     107             : 
     108             : err_out:
     109        4518 :         ext2_error(sb, __func__,
     110         502 :                         "Invalid block bitmap - "
     111             :                         "block_group = %d, block = %lu",
     112             :                         block_group, bitmap_blk);
     113         502 :         return 0;
     114             : }
     115             : 
     116             : /*
     117             :  * Read the bitmap for a given block_group,and validate the
     118             :  * bits for block/inode/inode tables are set in the bitmaps
     119             :  *
     120             :  * Return buffer_head on success or NULL in case of failure.
     121             :  */
     122             : static struct buffer_head *
     123             : read_block_bitmap(struct super_block *sb, unsigned int block_group)
     124             : {
     125         502 :         struct ext2_group_desc * desc;
     126        1004 :         struct buffer_head * bh = NULL;
     127         502 :         ext2_fsblk_t bitmap_blk;
     128         502 : 
     129        2510 :         desc = ext2_get_group_desc(sb, block_group, NULL);
     130        1506 :         if (!desc)
     131        1004 :                 return NULL;
     132        1004 :         bitmap_blk = le32_to_cpu(desc->bg_block_bitmap);
     133        1004 :         bh = sb_getblk(sb, bitmap_blk);
     134        2008 :         if (unlikely(!bh)) {
     135        1506 :                 ext2_error(sb, __func__,
     136             :                             "Cannot read block bitmap - "
     137             :                             "block_group = %d, block_bitmap = %u",
     138             :                             block_group, le32_to_cpu(desc->bg_block_bitmap));
     139         502 :                 return NULL;
     140             :         }
     141        2510 :         if (likely(bh_uptodate_or_lock(bh)))
     142         502 :                 return bh;
     143             : 
     144        1506 :         if (bh_submit_read(bh) < 0) {
     145        1004 :                 brelse(bh);
     146        1506 :                 ext2_error(sb, __func__,
     147             :                             "Cannot read block bitmap - "
     148             :                             "block_group = %d, block_bitmap = %u",
     149             :                             block_group, le32_to_cpu(desc->bg_block_bitmap));
     150         502 :                 return NULL;
     151             :         }
     152             : 
     153        1506 :         ext2_valid_block_bitmap(sb, desc, block_group, bh);
     154             :         /*
     155             :          * file system mounted not to panic on error, continue with corrupt
     156             :          * bitmap
     157             :          */
     158         502 :         return bh;
     159             : }
     160             : 
     161             : static void release_blocks(struct super_block *sb, int count)
     162             : {
     163         906 :         if (count) {
     164        1208 :                 struct ext2_sb_info *sbi = EXT2_SB(sb);
     165             : 
     166         604 :                 percpu_counter_add(&sbi->s_freeblocks_counter, count);
     167         302 :                 sb->s_dirt = 1;
     168             :         }
     169         604 : }
     170             : 
     171             : static void group_adjust_blocks(struct super_block *sb, int group_no,
     172             :         struct ext2_group_desc *desc, struct buffer_head *bh, int count)
     173             : {
     174        1806 :         if (count) {
     175        2408 :                 struct ext2_sb_info *sbi = EXT2_SB(sb);
     176         602 :                 unsigned free_blocks;
     177         602 : 
     178        3010 :                 spin_lock(sb_bgl_lock(sbi, group_no));
     179        1204 :                 free_blocks = le16_to_cpu(desc->bg_free_blocks_count);
     180         602 :                 desc->bg_free_blocks_count = cpu_to_le16(free_blocks + count);
     181        2408 :                 spin_unlock(sb_bgl_lock(sbi, group_no));
     182         602 :                 sb->s_dirt = 1;
     183         602 :                 mark_buffer_dirty(bh);
     184             :         }
     185        1204 : }
     186             : 
     187             : /*
     188             :  * The reservation window structure operations
     189             :  * --------------------------------------------
     190             :  * Operations include:
     191             :  * dump, find, add, remove, is_empty, find_next_reservable_window, etc.
     192             :  *
     193             :  * We use a red-black tree to represent per-filesystem reservation
     194             :  * windows.
     195             :  *
     196             :  */
     197             : 
     198             : /**
     199             :  * __rsv_window_dump() -- Dump the filesystem block allocation reservation map
     200             :  * @rb_root:            root of per-filesystem reservation rb tree
     201             :  * @verbose:            verbose mode
     202             :  * @fn:                 function which wishes to dump the reservation map
     203             :  *
     204             :  * If verbose is turned on, it will print the whole block reservation
     205             :  * windows(start, end). Otherwise, it will only print out the "bad" windows,
     206             :  * those windows that overlap with their immediate neighbors.
     207             :  */
     208             : #if 1
     209             : static void __rsv_window_dump(struct rb_root *root, int verbose,
     210             :                               const char *fn)
     211        1400 : {
     212        1400 :         struct rb_node *n;
     213        1400 :         struct ext2_reserve_window_node *rsv, *prev;
     214        1400 :         int bad;
     215        1400 : 
     216        1400 : restart:
     217        1400 :         n = rb_first(root);
     218        1400 :         bad = 0;
     219        2800 :         prev = NULL;
     220             : 
     221        1400 :         printk("Block Allocation Reservation Windows Map (%s):\n", fn);
     222        4200 :         while (n) {
     223        4200 :                 rsv = rb_entry(n, struct ext2_reserve_window_node, rsv_node);
     224        4200 :                 if (verbose)
     225        1400 :                         printk("reservation window 0x%p "
     226             :                                 "start: %lu, end: %lu\n",
     227             :                                 rsv, rsv->rsv_start, rsv->rsv_end);
     228        5600 :                 if (rsv->rsv_start && rsv->rsv_start >= rsv->rsv_end) {
     229        1400 :                         printk("Bad reservation %p (start >= end)\n",
     230             :                                rsv);
     231        1400 :                         bad = 1;
     232             :                 }
     233        5600 :                 if (prev && prev->rsv_end >= rsv->rsv_start) {
     234        1400 :                         printk("Bad reservation %p (prev->end >= start)\n",
     235             :                                rsv);
     236        1400 :                         bad = 1;
     237             :                 }
     238        2800 :                 if (bad) {
     239        2800 :                         if (!verbose) {
     240        1400 :                                 printk("Restarting reservation walk in verbose mode\n");
     241        1400 :                                 verbose = 1;
     242        1400 :                                 goto restart;
     243             :                         }
     244             :                 }
     245        1400 :                 n = rb_next(n);
     246        1400 :                 prev = rsv;
     247             :         }
     248        2800 :         printk("Window map complete.\n");
     249        8400 :         BUG_ON(bad);
     250             : }
     251        1400 : #define rsv_window_dump(root, verbose) \
     252             :         __rsv_window_dump((root), (verbose), __func__)
     253             : #else
     254             : #define rsv_window_dump(root, verbose) do {} while (0)
     255             : #endif
     256             : 
     257             : /**
     258             :  * goal_in_my_reservation()
     259             :  * @rsv:                inode's reservation window
     260             :  * @grp_goal:           given goal block relative to the allocation block group
     261             :  * @group:              the current allocation block group
     262             :  * @sb:                 filesystem super block
     263             :  *
     264             :  * Test if the given goal block (group relative) is within the file's
     265             :  * own block reservation window range.
     266             :  *
     267             :  * If the reservation window is outside the goal allocation group, return 0;
     268             :  * grp_goal (given goal block) could be -1, which means no specific
     269             :  * goal block. In this case, always return 1.
     270             :  * If the goal block is within the reservation window, return 1;
     271             :  * otherwise, return 0;
     272             :  */
     273             : static int
     274             : goal_in_my_reservation(struct ext2_reserve_window *rsv, ext2_grpblk_t grp_goal,
     275             :                         unsigned int group, struct super_block * sb)
     276             : {
     277         400 :         ext2_fsblk_t group_first_block, group_last_block;
     278         400 : 
     279        1200 :         group_first_block = ext2_group_first_block_no(sb, group);
     280        1200 :         group_last_block = group_first_block + EXT2_BLOCKS_PER_GROUP(sb) - 1;
     281             : 
     282        1600 :         if ((rsv->_rsv_start > group_last_block) ||
     283             :             (rsv->_rsv_end < group_first_block))
     284         400 :                 return 0;
     285        2400 :         if ((grp_goal >= 0) && ((grp_goal + group_first_block < rsv->_rsv_start)
     286             :                 || (grp_goal + group_first_block > rsv->_rsv_end)))
     287         400 :                 return 0;
     288         400 :         return 1;
     289             : }
     290             : 
     291             : /**
     292             :  * search_reserve_window()
     293             :  * @rb_root:            root of reservation tree
     294             :  * @goal:               target allocation block
     295             :  *
     296             :  * Find the reserved window which includes the goal, or the previous one
     297             :  * if the goal is not in any window.
     298             :  * Returns NULL if there are no windows or if all windows start after the goal.
     299             :  */
     300             : static struct ext2_reserve_window_node *
     301             : search_reserve_window(struct rb_root *root, ext2_fsblk_t goal)
     302             : {
     303         400 :         struct rb_node *n = root->rb_node;
     304         400 :         struct ext2_reserve_window_node *rsv;
     305         400 : 
     306        1200 :         if (!n)
     307         800 :                 return NULL;
     308             : 
     309             :         do {
     310         800 :                 rsv = rb_entry(n, struct ext2_reserve_window_node, rsv_node);
     311         400 : 
     312         800 :                 if (goal < rsv->rsv_start)
     313         400 :                         n = n->rb_left;
     314         800 :                 else if (goal > rsv->rsv_end)
     315         400 :                         n = n->rb_right;
     316             :                 else
     317         400 :                         return rsv;
     318         800 :         } while (n);
     319             :         /*
     320         400 :          * We've fallen off the end of the tree: the goal wasn't inside
     321             :          * any particular node.  OK, the previous node must be to one
     322             :          * side of the interval containing the goal.  If it's the RHS,
     323             :          * we need to back up one.
     324             :          */
     325         800 :         if (rsv->rsv_start > goal) {
     326         400 :                 n = rb_prev(&rsv->rsv_node);
     327         800 :                 rsv = rb_entry(n, struct ext2_reserve_window_node, rsv_node);
     328             :         }
     329         400 :         return rsv;
     330             : }
     331             : 
     332             : /*
     333             :  * ext2_rsv_window_add() -- Insert a window to the block reservation rb tree.
     334             :  * @sb:                 super block
     335             :  * @rsv:                reservation window to add
     336             :  *
     337             :  * Must be called with rsv_lock held.
     338             :  */
     339             : void ext2_rsv_window_add(struct super_block *sb,
     340             :                     struct ext2_reserve_window_node *rsv)
     341        1200 : {
     342        4800 :         struct rb_root *root = &EXT2_SB(sb)->s_rsv_window_root;
     343        2400 :         struct rb_node *node = &rsv->rsv_node;
     344        2400 :         ext2_fsblk_t start = rsv->rsv_start;
     345        1200 : 
     346        2400 :         struct rb_node ** p = &root->rb_node;
     347        2400 :         struct rb_node * parent = NULL;
     348        1200 :         struct ext2_reserve_window_node *this;
     349             : 
     350        3600 :         while (*p)
     351        1200 :         {
     352        2400 :                 parent = *p;
     353        2400 :                 this = rb_entry(parent, struct ext2_reserve_window_node, rsv_node);
     354             : 
     355        2400 :                 if (start < this->rsv_start)
     356        1200 :                         p = &(*p)->rb_left;
     357        2400 :                 else if (start > this->rsv_end)
     358        1200 :                         p = &(*p)->rb_right;
     359             :                 else {
     360        2400 :                         rsv_window_dump(root, 1);
     361        2400 :                         BUG();
     362             :                 }
     363             :         }
     364        2400 : 
     365        2400 :         rb_link_node(node, parent, p);
     366        1200 :         rb_insert_color(node, root);
     367        1200 : }
     368             : 
     369             : /**
     370             :  * rsv_window_remove() -- unlink a window from the reservation rb tree
     371             :  * @sb:                 super block
     372             :  * @rsv:                reservation window to remove
     373             :  *
     374             :  * Mark the block reservation window as not allocated, and unlink it
     375             :  * from the filesystem reservation window rb tree. Must be called with
     376             :  * rsv_lock held.
     377             :  */
     378             : static void rsv_window_remove(struct super_block *sb,
     379             :                               struct ext2_reserve_window_node *rsv)
     380        1227 : {
     381        1227 :         rsv->rsv_start = EXT2_RESERVE_WINDOW_NOT_ALLOCATED;
     382        1227 :         rsv->rsv_end = EXT2_RESERVE_WINDOW_NOT_ALLOCATED;
     383        1227 :         rsv->rsv_alloc_hit = 0;
     384        3681 :         rb_erase(&rsv->rsv_node, &EXT2_SB(sb)->s_rsv_window_root);
     385        1227 : }
     386             : 
     387             : /*
     388             :  * rsv_is_empty() -- Check if the reservation window is allocated.
     389             :  * @rsv:                given reservation window to check
     390             :  *
     391             :  * returns 1 if the end block is EXT2_RESERVE_WINDOW_NOT_ALLOCATED.
     392             :  */
     393             : static inline int rsv_is_empty(struct ext2_reserve_window *rsv)
     394             : {
     395             :         /* a valid reservation end block could not be 0 */
     396        1954 :         return (rsv->_rsv_end == EXT2_RESERVE_WINDOW_NOT_ALLOCATED);
     397             : }
     398             : 
     399             : /**
     400             :  * ext2_init_block_alloc_info()
     401             :  * @inode:              file inode structure
     402             :  *
     403             :  * Allocate and initialize the  reservation window structure, and
     404             :  * link the window to the ext2 inode structure at last
     405             :  *
     406             :  * The reservation window structure is only dynamically allocated
     407             :  * and linked to ext2 inode the first time the open file
     408             :  * needs a new block. So, before every ext2_new_block(s) call, for
     409             :  * regular files, we should check whether the reservation window
     410             :  * structure exists or not. In the latter case, this function is called.
     411             :  * Fail to do so will result in block reservation being turned off for that
     412             :  * open file.
     413             :  *
     414             :  * This function is called from ext2_get_blocks_handle(), also called
     415             :  * when setting the reservation window size through ioctl before the file
     416             :  * is open for write (needs block allocation).
     417             :  *
     418             :  * Needs truncate_mutex protection prior to calling this function.
     419             :  */
     420             : void ext2_init_block_alloc_info(struct inode *inode)
     421             : {
     422          16 :         struct ext2_inode_info *ei = EXT2_I(inode);
     423           8 :         struct ext2_block_alloc_info *block_i = ei->i_block_alloc_info;
     424           8 :         struct super_block *sb = inode->i_sb;
     425           4 : 
     426          16 :         block_i = kmalloc(sizeof(*block_i), GFP_NOFS);
     427          12 :         if (block_i) {
     428           8 :                 struct ext2_reserve_window_node *rsv = &block_i->rsv_window_node;
     429             : 
     430           4 :                 rsv->rsv_start = EXT2_RESERVE_WINDOW_NOT_ALLOCATED;
     431           4 :                 rsv->rsv_end = EXT2_RESERVE_WINDOW_NOT_ALLOCATED;
     432             : 
     433             :                 /*
     434             :                  * if filesystem is mounted with NORESERVATION, the goal
     435             :                  * reservation window size is set to zero to indicate
     436             :                  * block reservation is off
     437             :                  */
     438          16 :                 if (!test_opt(sb, RESERVATION))
     439           4 :                         rsv->rsv_goal_size = 0;
     440             :                 else
     441           4 :                         rsv->rsv_goal_size = EXT2_DEFAULT_RESERVE_BLOCKS;
     442           4 :                 rsv->rsv_alloc_hit = 0;
     443           4 :                 block_i->last_alloc_logical_block = 0;
     444           4 :                 block_i->last_alloc_physical_block = 0;
     445             :         }
     446           8 :         ei->i_block_alloc_info = block_i;
     447           8 : }
     448             : 
     449             : /**
     450             :  * ext2_discard_reservation()
     451             :  * @inode:              inode
     452             :  *
     453             :  * Discard(free) block reservation window on last file close, or truncate
     454             :  * or at last iput().
     455             :  *
     456             :  * It is being called in three cases:
     457             :  *      ext2_release_file(): last writer closes the file
     458             :  *      ext2_clear_inode(): last iput(), when nobody links to this file.
     459             :  *      ext2_truncate(): when the block indirect map is about to change.
     460             :  */
     461             : void ext2_discard_reservation(struct inode *inode)
     462             : {
     463         108 :         struct ext2_inode_info *ei = EXT2_I(inode);
     464          54 :         struct ext2_block_alloc_info *block_i = ei->i_block_alloc_info;
     465          27 :         struct ext2_reserve_window_node *rsv;
     466         108 :         spinlock_t *rsv_lock = &EXT2_SB(inode->i_sb)->s_rsv_window_lock;
     467          27 : 
     468          81 :         if (!block_i)
     469          54 :                 return;
     470          27 : 
     471          27 :         rsv = &block_i->rsv_window_node;
     472         108 :         if (!rsv_is_empty(&rsv->rsv_window)) {
     473          54 :                 spin_lock(rsv_lock);
     474         108 :                 if (!rsv_is_empty(&rsv->rsv_window))
     475          54 :                         rsv_window_remove(inode->i_sb, rsv);
     476         108 :                 spin_unlock(rsv_lock);
     477             :         }
     478          54 : }
     479             : 
     480             : /**
     481             :  * ext2_free_blocks_sb() -- Free given blocks and update quota and i_blocks
     482             :  * @inode:              inode
     483             :  * @block:              start physcial block to free
     484             :  * @count:              number of blocks to free
     485             :  */
     486             : void ext2_free_blocks (struct inode * inode, unsigned long block,
     487             :                        unsigned long count)
     488         302 : {
     489         604 :         struct buffer_head *bitmap_bh = NULL;
     490         302 :         struct buffer_head * bh2;
     491         302 :         unsigned long block_group;
     492         302 :         unsigned long bit;
     493         302 :         unsigned long i;
     494         302 :         unsigned long overflow;
     495         604 :         struct super_block * sb = inode->i_sb;
     496        1208 :         struct ext2_sb_info * sbi = EXT2_SB(sb);
     497         302 :         struct ext2_group_desc * desc;
     498         604 :         struct ext2_super_block * es = sbi->s_es;
     499         604 :         unsigned freed = 0, group_freed;
     500         302 : 
     501        2718 :         if (block < le32_to_cpu(es->s_first_data_block) ||
     502         302 :             block + count < block ||
     503         302 :             block + count > le32_to_cpu(es->s_blocks_count)) {
     504        1208 :                 ext2_error (sb, "ext2_free_blocks",
     505         302 :                             "Freeing blocks not in datazone - "
     506             :                             "block = %lu, count = %lu", block, count);
     507         302 :                 goto error_return;
     508             :         }
     509             : 
     510             :         ext2_debug ("freeing block(s) %lu-%lu\n", block, block + count - 1);
     511         302 : 
     512             : do_more:
     513         302 :         overflow = 0;
     514        1208 :         block_group = (block - le32_to_cpu(es->s_first_data_block)) /
     515             :                       EXT2_BLOCKS_PER_GROUP(sb);
     516        1208 :         bit = (block - le32_to_cpu(es->s_first_data_block)) %
     517             :                       EXT2_BLOCKS_PER_GROUP(sb);
     518             :         /*
     519             :          * Check to see if we are freeing blocks across a group
     520             :          * boundary.
     521             :          */
     522        1208 :         if (bit + count > EXT2_BLOCKS_PER_GROUP(sb)) {
     523         906 :                 overflow = bit + count - EXT2_BLOCKS_PER_GROUP(sb);
     524         302 :                 count -= overflow;
     525             :         }
     526        1208 :         brelse(bitmap_bh);
     527        1812 :         bitmap_bh = read_block_bitmap(sb, block_group);
     528         604 :         if (!bitmap_bh)
     529         302 :                 goto error_return;
     530             : 
     531        1208 :         desc = ext2_get_group_desc (sb, block_group, &bh2);
     532         604 :         if (!desc)
     533         302 :                 goto error_return;
     534             : 
     535        7248 :         if (in_range (le32_to_cpu(desc->bg_block_bitmap), block, count) ||
     536             :             in_range (le32_to_cpu(desc->bg_inode_bitmap), block, count) ||
     537             :             in_range (block, le32_to_cpu(desc->bg_inode_table),
     538             :                       sbi->s_itb_per_group) ||
     539             :             in_range (block + count - 1, le32_to_cpu(desc->bg_inode_table),
     540             :                       sbi->s_itb_per_group)) {
     541         906 :                 ext2_error (sb, "ext2_free_blocks",
     542             :                             "Freeing blocks in system zones - "
     543             :                             "Block = %lu, count = %lu",
     544             :                             block, count);
     545         302 :                 goto error_return;
     546             :         }
     547             : 
     548        2114 :         for (i = 0, group_freed = 0; i < count; i++) {
     549        2416 :                 if (!ext2_clear_bit_atomic(sb_bgl_lock(sbi, block_group),
     550         302 :                                                 bit + i, bitmap_bh->b_data)) {
     551         906 :                         ext2_error(sb, __func__,
     552             :                                 "bit already cleared for block %lu", block + i);
     553             :                 } else {
     554         302 :                         group_freed++;
     555             :                 }
     556             :         }
     557             : 
     558         302 :         mark_buffer_dirty(bitmap_bh);
     559         604 :         if (sb->s_flags & MS_SYNCHRONOUS)
     560         302 :                 sync_dirty_buffer(bitmap_bh);
     561             : 
     562         906 :         group_adjust_blocks(sb, block_group, desc, bh2, group_freed);
     563         302 :         freed += group_freed;
     564             : 
     565         604 :         if (overflow) {
     566         302 :                 block += count;
     567         302 :                 count = overflow;
     568         302 :                 goto do_more;
     569             :         }
     570             : error_return:
     571        3020 :         brelse(bitmap_bh);
     572        1208 :         release_blocks(sb, freed);
     573         604 :         vfs_dq_free_block(inode, freed);
     574         302 : }
     575             : 
     576             : /**
     577             :  * bitmap_search_next_usable_block()
     578             :  * @start:              the starting block (group relative) of the search
     579             :  * @bh:                 bufferhead contains the block group bitmap
     580             :  * @maxblocks:          the ending block (group relative) of the reservation
     581             :  *
     582             :  * The bitmap search --- search forward through the actual bitmap on disk until
     583             :  * we find a bit free.
     584             :  */
     585             : static ext2_grpblk_t
     586             : bitmap_search_next_usable_block(ext2_grpblk_t start, struct buffer_head *bh,
     587             :                                         ext2_grpblk_t maxblocks)
     588             : {
     589        1400 :         ext2_grpblk_t next;
     590        1400 : 
     591        4200 :         next = ext2_find_next_zero_bit(bh->b_data, maxblocks, start);
     592        2800 :         if (next >= maxblocks)
     593        1400 :                 return -1;
     594        1400 :         return next;
     595             : }
     596             : 
     597             : /**
     598             :  * find_next_usable_block()
     599             :  * @start:              the starting block (group relative) to find next
     600             :  *                      allocatable block in bitmap.
     601             :  * @bh:                 bufferhead contains the block group bitmap
     602             :  * @maxblocks:          the ending block (group relative) for the search
     603             :  *
     604             :  * Find an allocatable block in a bitmap.  We perform the "most
     605             :  * appropriate allocation" algorithm of looking for a free block near
     606             :  * the initial goal; then for a free byte somewhere in the bitmap;
     607             :  * then for any free bit in the bitmap.
     608             :  */
     609             : static ext2_grpblk_t
     610             : find_next_usable_block(int start, struct buffer_head *bh, int maxblocks)
     611             : {
     612        1000 :         ext2_grpblk_t here, next;
     613        1000 :         char *p, *r;
     614        1000 : 
     615        3000 :         if (start > 0) {
     616        1000 :                 /*
     617        1000 :                  * The goal was occupied; search forward for a free 
     618        1000 :                  * block within the next XX blocks.
     619             :                  *
     620             :                  * end_goal is more or less random, but it has to be
     621             :                  * less than EXT2_BLOCKS_PER_GROUP. Aligning up to the
     622             :                  * next 64-bit boundary is simple..
     623             :                  */
     624        1000 :                 ext2_grpblk_t end_goal = (start + 63) & ~63;
     625        2000 :                 if (end_goal > maxblocks)
     626        1000 :                         end_goal = maxblocks;
     627        3000 :                 here = ext2_find_next_zero_bit(bh->b_data, end_goal, start);
     628        2000 :                 if (here < end_goal)
     629        1000 :                         return here;
     630             :                 ext2_debug("Bit not found near goal\n");
     631             :         }
     632             : 
     633        1000 :         here = start;
     634        2000 :         if (here < 0)
     635        1000 :                 here = 0;
     636             : 
     637        1000 :         p = ((char *)bh->b_data) + (here >> 3);
     638        2000 :         r = memscan(p, 0, ((maxblocks + 7) >> 3) - (here >> 3));
     639        2000 :         next = (r - ((char *)bh->b_data)) << 3;
     640             : 
     641        4000 :         if (next < maxblocks && next >= here)
     642        1000 :                 return next;
     643             : 
     644        2000 :         here = bitmap_search_next_usable_block(here, bh, maxblocks);
     645        1000 :         return here;
     646             : }
     647             : 
     648             : /*
     649             :  * ext2_try_to_allocate()
     650             :  * @sb:                 superblock
     651             :  * @handle:             handle to this transaction
     652             :  * @group:              given allocation block group
     653             :  * @bitmap_bh:          bufferhead holds the block bitmap
     654             :  * @grp_goal:           given target block within the group
     655             :  * @count:              target number of blocks to allocate
     656             :  * @my_rsv:             reservation window
     657             :  *
     658             :  * Attempt to allocate blocks within a give range. Set the range of allocation
     659             :  * first, then find the first free bit(s) from the bitmap (within the range),
     660             :  * and at last, allocate the blocks by claiming the found free bit as allocated.
     661             :  *
     662             :  * To set the range of this allocation:
     663             :  *      if there is a reservation window, only try to allocate block(s)
     664             :  *      from the file's own reservation window;
     665             :  *      Otherwise, the allocation range starts from the give goal block,
     666             :  *      ends at the block group's last block.
     667             :  *
     668             :  * If we failed to allocate the desired block then we may end up crossing to a
     669             :  * new bitmap.
     670             :  */
     671             : static int
     672             : ext2_try_to_allocate(struct super_block *sb, int group,
     673             :                         struct buffer_head *bitmap_bh, ext2_grpblk_t grp_goal,
     674             :                         unsigned long *count,
     675        1000 :                         struct ext2_reserve_window *my_rsv)
     676        1000 : {
     677        1000 :         ext2_fsblk_t group_first_block;
     678        1000 :         ext2_grpblk_t start, end;
     679        2000 :         unsigned long num = 0;
     680        1000 : 
     681        1000 :         /* we do allocation within the reservation window if we have a window */
     682        3000 :         if (my_rsv) {
     683        3000 :                 group_first_block = ext2_group_first_block_no(sb, group);
     684        3000 :                 if (my_rsv->_rsv_start >= group_first_block)
     685        3000 :                         start = my_rsv->_rsv_start - group_first_block;
     686        1000 :                 else
     687        1000 :                         /* reservation window cross group boundary */
     688        1000 :                         start = 0;
     689        2000 :                 end = my_rsv->_rsv_end - group_first_block + 1;
     690        4000 :                 if (end > EXT2_BLOCKS_PER_GROUP(sb))
     691             :                         /* reservation window crosses group boundary */
     692        4000 :                         end = EXT2_BLOCKS_PER_GROUP(sb);
     693        8000 :                 if ((start <= grp_goal) && (grp_goal < end))
     694        2000 :                         start = grp_goal;
     695             :                 else
     696        2000 :                         grp_goal = -1;
     697             :         } else {
     698        2000 :                 if (grp_goal > 0)
     699        1000 :                         start = grp_goal;
     700             :                 else
     701        1000 :                         start = 0;
     702        4000 :                 end = EXT2_BLOCKS_PER_GROUP(sb);
     703             :         }
     704             : 
     705       12000 :         BUG_ON(start > EXT2_BLOCKS_PER_GROUP(sb));
     706             : 
     707             : repeat:
     708        2000 :         if (grp_goal < 0) {
     709        3000 :                 grp_goal = find_next_usable_block(start, bitmap_bh, end);
     710        3000 :                 if (grp_goal < 0)
     711        1000 :                         goto fail_access;
     712        2000 :                 if (!my_rsv) {
     713             :                         int i;
     714             : 
     715       11000 :                         for (i = 0; i < 7 && grp_goal > start &&
     716        1000 :                                         !ext2_test_bit(grp_goal - 1,
     717             :                                                         bitmap_bh->b_data);
     718        3000 :                                         i++, grp_goal--)
     719        1000 :                                 ;
     720             :                 }
     721        1000 :         }
     722        4000 :         start = grp_goal;
     723             : 
     724       14000 :         if (ext2_set_bit_atomic(sb_bgl_lock(EXT2_SB(sb), group), grp_goal,
     725             :                                                         bitmap_bh->b_data)) {
     726        1000 :                 /*
     727             :                  * The block was allocated by another thread, or it was
     728             :                  * allocated and then freed by another thread
     729             :                  */
     730        1000 :                 start++;
     731        1000 :                 grp_goal++;
     732        2000 :                 if (start >= end)
     733        1000 :                         goto fail_access;
     734        1000 :                 goto repeat;
     735             :         }
     736        1000 :         num++;
     737        1000 :         grp_goal++;
     738       10000 :         while (num < *count && grp_goal < end
     739        1000 :                 && !ext2_set_bit_atomic(sb_bgl_lock(EXT2_SB(sb), group),
     740             :                                         grp_goal, bitmap_bh->b_data)) {
     741        2000 :                 num++;
     742        1000 :                 grp_goal++;
     743        1000 :         }
     744        3000 :         *count = num;
     745        2000 :         return grp_goal - num;
     746        2000 : fail_access:
     747        2000 :         *count = num;
     748        2000 :         return -1;
     749        1000 : }
     750             : 
     751             : /**
     752             :  *      find_next_reservable_window():
     753             :  *              find a reservable space within the given range.
     754             :  *              It does not allocate the reservation window for now:
     755             :  *              alloc_new_reservation() will do the work later.
     756             :  *
     757             :  *      @search_head: the head of the searching list;
     758             :  *              This is not necessarily the list head of the whole filesystem
     759             :  *
     760             :  *              We have both head and start_block to assist the search
     761             :  *              for the reservable space. The list starts from head,
     762             :  *              but we will shift to the place where start_block is,
     763             :  *              then start from there, when looking for a reservable space.
     764             :  *
     765             :  *      @size: the target new reservation window size
     766             :  *
     767             :  *      @group_first_block: the first block we consider to start
     768             :  *                      the real search from
     769             :  *
     770             :  *      @last_block:
     771             :  *              the maximum block number that our goal reservable space
     772             :  *              could start from. This is normally the last block in this
     773             :  *              group. The search will end when we found the start of next
     774             :  *              possible reservable space is out of this boundary.
     775             :  *              This could handle the cross boundary reservation window
     776             :  *              request.
     777             :  *
     778             :  *      basically we search from the given range, rather than the whole
     779             :  *      reservation double linked list, (start_block, last_block)
     780             :  *      to find a free region that is of my size and has not
     781             :  *      been reserved.
     782             :  *
     783             :  */
     784             : static int find_next_reservable_window(
     785             :                                 struct ext2_reserve_window_node *search_head,
     786             :                                 struct ext2_reserve_window_node *my_rsv,
     787             :                                 struct super_block * sb,
     788         400 :                                 ext2_fsblk_t start_block,
     789         400 :                                 ext2_fsblk_t last_block)
     790         400 : {
     791         400 :         struct rb_node *next;
     792         400 :         struct ext2_reserve_window_node *rsv, *prev;
     793         400 :         ext2_fsblk_t cur;
     794        1200 :         int size = my_rsv->rsv_goal_size;
     795             : 
     796             :         /* TODO: make the start of the reservation window byte-aligned */
     797             :         /* cur = *start_block & ~7;*/
     798         400 :         cur = start_block;
     799         400 :         rsv = search_head;
     800         800 :         if (!rsv)
     801         400 :                 return -1;
     802             : 
     803             :         while (1) {
     804         800 :                 if (cur <= rsv->rsv_end)
     805         800 :                         cur = rsv->rsv_end + 1;
     806             : 
     807             :                 /* TODO?
     808             :                  * in the case we could not find a reservable space
     809             :                  * that is what is expected, during the re-search, we could
     810             :                  * remember what's the largest reservable space we could have
     811             :                  * and return that one.
     812             :                  *
     813             :                  * For now it will fail if we could not find the reservable
     814             :                  * space with expected-size (or more)...
     815             :                  */
     816         800 :                 if (cur > last_block)
     817         400 :                         return -1;              /* fail */
     818             : 
     819         400 :                 prev = rsv;
     820         400 :                 next = rb_next(&rsv->rsv_node);
     821         800 :                 rsv = rb_entry(next,struct ext2_reserve_window_node,rsv_node);
     822             : 
     823             :                 /*
     824             :                  * Reached the last reservation, we can just append to the
     825             :                  * previous one.
     826             :                  */
     827         800 :                 if (!next)
     828         400 :                         break;
     829             : 
     830         800 :                 if (cur + size <= rsv->rsv_start) {
     831             :                         /*
     832             :                          * Found a reserveable space big enough.  We could
     833             :                          * have a reservation across the group boundary here
     834             :                          */
     835         400 :                         break;
     836             :                 }
     837         400 :         }
     838         400 :         /*
     839             :          * we come here either :
     840             :          * when we reach the end of the whole list,
     841             :          * and there is empty reservable space after last entry in the list.
     842             :          * append it to the end of the list.
     843             :          *
     844             :          * or we found one reservable space in the middle of the list,
     845             :          * return the reservation window that we could append to.
     846             :          * succeed.
     847             :          */
     848             : 
     849        2400 :         if ((prev != my_rsv) && (!rsv_is_empty(&my_rsv->rsv_window)))
     850         800 :                 rsv_window_remove(sb, my_rsv);
     851             : 
     852             :         /*
     853             :          * Let's book the whole avaliable window for now.  We will check the
     854             :          * disk bitmap later and then, if there are free blocks then we adjust
     855             :          * the window size if it's larger than requested.
     856             :          * Otherwise, we will remove this node from the tree next time
     857             :          * call find_next_reservable_window.
     858             :          */
     859        1200 :         my_rsv->rsv_start = cur;
     860        1200 :         my_rsv->rsv_end = cur + size - 1;
     861        1200 :         my_rsv->rsv_alloc_hit = 0;
     862             : 
     863        2400 :         if (prev != my_rsv)
     864        2400 :                 ext2_rsv_window_add(sb, my_rsv);
     865             : 
     866        1600 :         return 0;
     867             : }
     868             : 
     869             : /**
     870             :  *      alloc_new_reservation()--allocate a new reservation window
     871             :  *
     872             :  *              To make a new reservation, we search part of the filesystem
     873             :  *              reservation list (the list that inside the group). We try to
     874             :  *              allocate a new reservation window near the allocation goal,
     875             :  *              or the beginning of the group, if there is no goal.
     876             :  *
     877             :  *              We first find a reservable space after the goal, then from
     878             :  *              there, we check the bitmap for the first free block after
     879             :  *              it. If there is no free block until the end of group, then the
     880             :  *              whole group is full, we failed. Otherwise, check if the free
     881             :  *              block is inside the expected reservable space, if so, we
     882             :  *              succeed.
     883             :  *              If the first free block is outside the reservable space, then
     884             :  *              start from the first free block, we search for next available
     885             :  *              space, and go on.
     886             :  *
     887             :  *      on succeed, a new reservation will be found and inserted into the list
     888             :  *      It contains at least one free block, and it does not overlap with other
     889             :  *      reservation windows.
     890             :  *
     891             :  *      failed: we failed to find a reservation window in this group
     892             :  *
     893             :  *      @rsv: the reservation
     894             :  *
     895             :  *      @grp_goal: The goal (group-relative).  It is where the search for a
     896             :  *              free reservable space should start from.
     897             :  *              if we have a goal(goal >0 ), then start from there,
     898             :  *              no goal(goal = -1), we start from the first block
     899             :  *              of the group.
     900             :  *
     901             :  *      @sb: the super block
     902             :  *      @group: the group we are trying to allocate in
     903             :  *      @bitmap_bh: the block group block bitmap
     904             :  *
     905             :  */
     906             : static int alloc_new_reservation(struct ext2_reserve_window_node *my_rsv,
     907             :                 ext2_grpblk_t grp_goal, struct super_block *sb,
     908             :                 unsigned int group, struct buffer_head *bitmap_bh)
     909         400 : {
     910         400 :         struct ext2_reserve_window_node *search_head;
     911         400 :         ext2_fsblk_t group_first_block, group_end_block, start_block;
     912         400 :         ext2_grpblk_t first_free_block;
     913        1600 :         struct rb_root *fs_rsv_root = &EXT2_SB(sb)->s_rsv_window_root;
     914         400 :         unsigned long size;
     915         400 :         int ret;
     916        1600 :         spinlock_t *rsv_lock = &EXT2_SB(sb)->s_rsv_window_lock;
     917         400 : 
     918        1200 :         group_first_block = ext2_group_first_block_no(sb, group);
     919        1600 :         group_end_block = group_first_block + (EXT2_BLOCKS_PER_GROUP(sb) - 1);
     920         400 : 
     921        1200 :         if (grp_goal < 0)
     922         800 :                 start_block = group_first_block;
     923         400 :         else
     924         400 :                 start_block = grp_goal + group_first_block;
     925             : 
     926         800 :         size = my_rsv->rsv_goal_size;
     927             : 
     928        1600 :         if (!rsv_is_empty(&my_rsv->rsv_window)) {
     929             :                 /*
     930             :                  * if the old reservation is cross group boundary
     931             :                  * and if the goal is inside the old reservation window,
     932             :                  * we will come here when we just failed to allocate from
     933             :                  * the first part of the window. We still have another part
     934             :                  * that belongs to the next group. In this case, there is no
     935             :                  * point to discard our window and try to allocate a new one
     936             :                  * in this group(which will fail). we should
     937             :                  * keep the reservation window, just simply move on.
     938             :                  *
     939             :                  * Maybe we could shift the start block of the reservation
     940             :                  * window to the first block of next group.
     941             :                  */
     942             : 
     943        2400 :                 if ((my_rsv->rsv_start <= group_end_block) &&
     944             :                                 (my_rsv->rsv_end > group_end_block) &&
     945             :                                 (start_block >= my_rsv->rsv_start))
     946         400 :                         return -1;
     947             : 
     948        1200 :                 if ((my_rsv->rsv_alloc_hit >
     949             :                      (my_rsv->rsv_end - my_rsv->rsv_start + 1) / 2)) {
     950             :                         /*
     951             :                          * if the previously allocation hit ratio is
     952             :                          * greater than 1/2, then we double the size of
     953             :                          * the reservation window the next time,
     954             :                          * otherwise we keep the same size window
     955             :                          */
     956         400 :                         size = size * 2;
     957         800 :                         if (size > EXT2_MAX_RESERVE_BLOCKS)
     958         400 :                                 size = EXT2_MAX_RESERVE_BLOCKS;
     959         400 :                         my_rsv->rsv_goal_size= size;
     960             :                 }
     961             :         }
     962             : 
     963         800 :         spin_lock(rsv_lock);
     964             :         /*
     965             :          * shift the search start to the window near the goal block
     966             :          */
     967        1200 :         search_head = search_reserve_window(fs_rsv_root, start_block);
     968             : 
     969         400 :         /*
     970             :          * find_next_reservable_window() simply finds a reservable window
     971             :          * inside the given range(start_block, group_end_block).
     972             :          *
     973             :          * To make sure the reservation window has a free bit inside it, we
     974             :          * need to check the bitmap after we found a reservable window.
     975             :          */
     976             : retry:
     977        2400 :         ret = find_next_reservable_window(search_head, my_rsv, sb,
     978             :                                                 start_block, group_end_block);
     979             : 
     980         800 :         if (ret == -1) {
     981        1600 :                 if (!rsv_is_empty(&my_rsv->rsv_window))
     982         800 :                         rsv_window_remove(sb, my_rsv);
     983        1600 :                 spin_unlock(rsv_lock);
     984         400 :                 return -1;
     985             :         }
     986             : 
     987             :         /*
     988             :          * On success, find_next_reservable_window() returns the
     989             :          * reservation window where there is a reservable space after it.
     990             :          * Before we reserve this reservable space, we need
     991             :          * to make sure there is at least a free block inside this region.
     992             :          *
     993             :          * Search the first free bit on the block bitmap.  Search starts from
     994             :          * the start block of the reservable space we just found.
     995             :          */
     996         800 :         spin_unlock(rsv_lock);
     997         800 :         first_free_block = bitmap_search_next_usable_block(
     998             :                         my_rsv->rsv_start - group_first_block,
     999             :                         bitmap_bh, group_end_block - group_first_block + 1);
    1000             : 
    1001         800 :         if (first_free_block < 0) {
    1002             :                 /*
    1003             :                  * no free block left on the bitmap, no point
    1004             :                  * to reserve the space. return failed.
    1005             :                  */
    1006         800 :                 spin_lock(rsv_lock);
    1007        1600 :                 if (!rsv_is_empty(&my_rsv->rsv_window))
    1008         800 :                         rsv_window_remove(sb, my_rsv);
    1009        1600 :                 spin_unlock(rsv_lock);
    1010         400 :                 return -1;              /* failed */
    1011             :         }
    1012             : 
    1013         400 :         start_block = first_free_block + group_first_block;
    1014             :         /*
    1015             :          * check if the first free block is within the
    1016             :          * free space we just reserved
    1017             :          */
    1018        1600 :         if (start_block >= my_rsv->rsv_start && start_block <= my_rsv->rsv_end)
    1019         400 :                 return 0;               /* success */
    1020             :         /*
    1021             :          * if the first free bit we found is out of the reservable space
    1022             :          * continue search for next reservable space,
    1023             :          * start from where the free block is,
    1024             :          * we also shift the list head to where we stopped last time
    1025             :          */
    1026         400 :         search_head = my_rsv;
    1027         800 :         spin_lock(rsv_lock);
    1028         400 :         goto retry;
    1029             : }
    1030             : 
    1031             : /**
    1032             :  * try_to_extend_reservation()
    1033             :  * @my_rsv:             given reservation window
    1034             :  * @sb:                 super block
    1035             :  * @size:               the delta to extend
    1036             :  *
    1037             :  * Attempt to expand the reservation window large enough to have
    1038             :  * required number of free blocks
    1039             :  *
    1040             :  * Since ext2_try_to_allocate() will always allocate blocks within
    1041             :  * the reservation window range, if the window size is too small,
    1042             :  * multiple blocks allocation has to stop at the end of the reservation
    1043             :  * window. To make this more efficient, given the total number of
    1044             :  * blocks needed and the current size of the window, we try to
    1045             :  * expand the reservation window size if necessary on a best-effort
    1046             :  * basis before ext2_new_blocks() tries to allocate blocks.
    1047             :  */
    1048             : static void try_to_extend_reservation(struct ext2_reserve_window_node *my_rsv,
    1049             :                         struct super_block *sb, int size)
    1050             : {
    1051         200 :         struct ext2_reserve_window_node *next_rsv;
    1052         200 :         struct rb_node *next;
    1053         800 :         spinlock_t *rsv_lock = &EXT2_SB(sb)->s_rsv_window_lock;
    1054         200 : 
    1055        1000 :         if (!spin_trylock(rsv_lock))
    1056         400 :                 return;
    1057             : 
    1058         200 :         next = rb_next(&my_rsv->rsv_node);
    1059             : 
    1060         400 :         if (!next)
    1061         200 :                 my_rsv->rsv_end += size;
    1062             :         else {
    1063         400 :                 next_rsv = rb_entry(next, struct ext2_reserve_window_node, rsv_node);
    1064             : 
    1065         400 :                 if ((next_rsv->rsv_start - my_rsv->rsv_end - 1) >= size)
    1066         200 :                         my_rsv->rsv_end += size;
    1067             :                 else
    1068         200 :                         my_rsv->rsv_end = next_rsv->rsv_start - 1;
    1069             :         }
    1070         400 :         spin_unlock(rsv_lock);
    1071         200 : }
    1072             : 
    1073             : /**
    1074             :  * ext2_try_to_allocate_with_rsv()
    1075             :  * @sb:                 superblock
    1076             :  * @group:              given allocation block group
    1077             :  * @bitmap_bh:          bufferhead holds the block bitmap
    1078             :  * @grp_goal:           given target block within the group
    1079             :  * @count:              target number of blocks to allocate
    1080             :  * @my_rsv:             reservation window
    1081             :  *
    1082             :  * This is the main function used to allocate a new block and its reservation
    1083             :  * window.
    1084             :  *
    1085             :  * Each time when a new block allocation is need, first try to allocate from
    1086             :  * its own reservation.  If it does not have a reservation window, instead of
    1087             :  * looking for a free bit on bitmap first, then look up the reservation list to
    1088             :  * see if it is inside somebody else's reservation window, we try to allocate a
    1089             :  * reservation window for it starting from the goal first. Then do the block
    1090             :  * allocation within the reservation window.
    1091             :  *
    1092             :  * This will avoid keeping on searching the reservation list again and
    1093             :  * again when somebody is looking for a free block (without
    1094             :  * reservation), and there are lots of free blocks, but they are all
    1095             :  * being reserved.
    1096             :  *
    1097             :  * We use a red-black tree for the per-filesystem reservation list.
    1098             :  */
    1099             : static ext2_grpblk_t
    1100             : ext2_try_to_allocate_with_rsv(struct super_block *sb, unsigned int group,
    1101             :                         struct buffer_head *bitmap_bh, ext2_grpblk_t grp_goal,
    1102             :                         struct ext2_reserve_window_node * my_rsv,
    1103             :                         unsigned long *count)
    1104             : {
    1105         200 :         ext2_fsblk_t group_first_block, group_last_block;
    1106         400 :         ext2_grpblk_t ret = 0;
    1107         400 :         unsigned long num = *count;
    1108         200 : 
    1109         200 :         /*
    1110         200 :          * we don't deal with reservation when
    1111         200 :          * filesystem is mounted without reservation
    1112         200 :          * or the file is not a regular file
    1113         200 :          * or last attempt to allocate a block with reservation turned on failed
    1114         200 :          */
    1115         600 :         if (my_rsv == NULL) {
    1116        1200 :                 return ext2_try_to_allocate(sb, group, bitmap_bh,
    1117             :                                                 grp_goal, count, NULL);
    1118             :         }
    1119             :         /*
    1120             :          * grp_goal is a group relative block number (if there is a goal)
    1121             :          * 0 <= grp_goal < EXT2_BLOCKS_PER_GROUP(sb)
    1122             :          * first block is a filesystem wide block number
    1123             :          * first block is the block number of the first block in this group
    1124             :          */
    1125         400 :         group_first_block = ext2_group_first_block_no(sb, group);
    1126         600 :         group_last_block = group_first_block + (EXT2_BLOCKS_PER_GROUP(sb) - 1);
    1127             : 
    1128         200 :         /*
    1129             :          * Basically we will allocate a new block from inode's reservation
    1130             :          * window.
    1131             :          *
    1132             :          * We need to allocate a new reservation window, if:
    1133             :          * a) inode does not have a reservation window; or
    1134             :          * b) last attempt to allocate a block from existing reservation
    1135             :          *    failed; or
    1136             :          * c) we come here with a goal and with a reservation window
    1137             :          *
    1138             :          * We do not need to allocate a new reservation window if we come here
    1139             :          * at the beginning with a goal and the goal is inside the window, or
    1140             :          * we don't have a goal but already have a reservation window.
    1141             :          * then we could go to allocate from the reservation window directly.
    1142             :          */
    1143             :         while (1) {
    1144        2200 :                 if (rsv_is_empty(&my_rsv->rsv_window) || (ret < 0) ||
    1145         200 :                         !goal_in_my_reservation(&my_rsv->rsv_window,
    1146             :                                                 grp_goal, group, sb)) {
    1147        1200 :                         if (my_rsv->rsv_goal_size < *count)
    1148         400 :                                 my_rsv->rsv_goal_size = *count;
    1149        2000 :                         ret = alloc_new_reservation(my_rsv, grp_goal, sb,
    1150             :                                                         group, bitmap_bh);
    1151         400 :                         if (ret < 0)
    1152         200 :                                 break;                  /* failed */
    1153             : 
    1154         800 :                         if (!goal_in_my_reservation(&my_rsv->rsv_window,
    1155             :                                                         grp_goal, group, sb))
    1156         200 :                                 grp_goal = -1;
    1157         400 :                 } else if (grp_goal >= 0) {
    1158         200 :                         int curr = my_rsv->rsv_end -
    1159             :                                         (grp_goal + group_first_block) + 1;
    1160             : 
    1161         400 :                         if (curr < *count)
    1162         600 :                                 try_to_extend_reservation(my_rsv, sb,
    1163             :                                                         *count - curr);
    1164             :                 }
    1165             : 
    1166        2400 :                 if ((my_rsv->rsv_start > group_last_block) ||
    1167             :                                 (my_rsv->rsv_end < group_first_block)) {
    1168        1600 :                         rsv_window_dump(&EXT2_SB(sb)->s_rsv_window_root, 1);
    1169         400 :                         BUG();
    1170             :                 }
    1171        4000 :                 ret = ext2_try_to_allocate(sb, group, bitmap_bh, grp_goal,
    1172             :                                            &num, &my_rsv->rsv_window);
    1173         400 :                 if (ret >= 0) {
    1174         200 :                         my_rsv->rsv_alloc_hit += num;
    1175         200 :                         *count = num;
    1176         200 :                         break;                          /* succeed */
    1177             :                 }
    1178         200 :                 num = *count;
    1179         200 :         }
    1180         800 :         return ret;
    1181             : }
    1182             : 
    1183             : /**
    1184             :  * ext2_has_free_blocks()
    1185             :  * @sbi:                in-core super block structure.
    1186             :  *
    1187             :  * Check if filesystem has at least 1 free block available for allocation.
    1188             :  */
    1189             : static int ext2_has_free_blocks(struct ext2_sb_info *sbi)
    1190             : {
    1191         100 :         ext2_fsblk_t free_blocks, root_blocks;
    1192         100 : 
    1193         400 :         free_blocks = percpu_counter_read_positive(&sbi->s_freeblocks_counter);
    1194         300 :         root_blocks = le32_to_cpu(sbi->s_es->s_r_blocks_count);
    1195        1600 :         if (free_blocks < root_blocks + 1 && !capable(CAP_SYS_RESOURCE) &&
    1196         100 :                 sbi->s_resuid != current_fsuid() &&
    1197             :                 (sbi->s_resgid == 0 || !in_group_p (sbi->s_resgid))) {
    1198         200 :                 return 0;
    1199             :         }
    1200         200 :         return 1;
    1201             : }
    1202             : 
    1203             : /*
    1204             :  * ext2_new_blocks() -- core block(s) allocation function
    1205             :  * @inode:              file inode
    1206             :  * @goal:               given target block(filesystem wide)
    1207             :  * @count:              target number of blocks to allocate
    1208             :  * @errp:               error code
    1209             :  *
    1210             :  * ext2_new_blocks uses a goal block to assist allocation.  If the goal is
    1211             :  * free, or there is a free block within 32 blocks of the goal, that block
    1212             :  * is allocated.  Otherwise a forward search is made for a free block; within 
    1213             :  * each block group the search first looks for an entire free byte in the block
    1214             :  * bitmap, and then for any free bit if that fails.
    1215             :  * This function also updates quota and i_blocks field.
    1216             :  */
    1217             : ext2_fsblk_t ext2_new_blocks(struct inode *inode, ext2_fsblk_t goal,
    1218             :                     unsigned long *count, int *errp)
    1219             : {
    1220         200 :         struct buffer_head *bitmap_bh = NULL;
    1221         100 :         struct buffer_head *gdp_bh;
    1222         100 :         int group_no;
    1223         100 :         int goal_group;
    1224         100 :         ext2_grpblk_t grp_target_blk;   /* blockgroup relative goal block */
    1225         100 :         ext2_grpblk_t grp_alloc_blk;    /* blockgroup-relative allocated block*/
    1226         100 :         ext2_fsblk_t ret_block;         /* filesyetem-wide allocated block */
    1227         100 :         int bgi;                        /* blockgroup iteration index */
    1228         200 :         int performed_allocation = 0;
    1229         100 :         ext2_grpblk_t free_blocks;      /* number of free blocks in a group */
    1230         100 :         struct super_block *sb;
    1231         100 :         struct ext2_group_desc *gdp;
    1232         100 :         struct ext2_super_block *es;
    1233         100 :         struct ext2_sb_info *sbi;
    1234         200 :         struct ext2_reserve_window_node *my_rsv = NULL;
    1235         100 :         struct ext2_block_alloc_info *block_i;
    1236         200 :         unsigned short windowsz = 0;
    1237         100 :         unsigned long ngroups;
    1238         200 :         unsigned long num = *count;
    1239         100 : 
    1240         200 :         *errp = -ENOSPC;
    1241         200 :         sb = inode->i_sb;
    1242         300 :         if (!sb) {
    1243         200 :                 printk("ext2_new_blocks: nonexistent device");
    1244         200 :                 return 0;
    1245         100 :         }
    1246         100 : 
    1247         100 :         /*
    1248         100 :          * Check quota for allocation of this block.
    1249         100 :          */
    1250         400 :         if (vfs_dq_alloc_block(inode, num)) {
    1251         100 :                 *errp = -EDQUOT;
    1252         100 :                 return 0;
    1253             :         }
    1254             : 
    1255         200 :         sbi = EXT2_SB(sb);
    1256         300 :         es = EXT2_SB(sb)->s_es;
    1257             :         ext2_debug("goal=%lu.\n", goal);
    1258             :         /*
    1259             :          * Allocate a block from reservation only when
    1260             :          * filesystem is mounted with reservation(default,-o reservation), and
    1261             :          * it's a regular file, and
    1262             :          * the desired window size is greater than 0 (One could use ioctl
    1263             :          * command EXT2_IOC_SETRSVSZ to set the window size to 0 to turn off
    1264             :          * reservation on that particular file)
    1265             :          */
    1266         300 :         block_i = EXT2_I(inode)->i_block_alloc_info;
    1267         200 :         if (block_i) {
    1268         100 :                 windowsz = block_i->rsv_window_node.rsv_goal_size;
    1269         200 :                 if (windowsz > 0)
    1270         100 :                         my_rsv = &block_i->rsv_window_node;
    1271             :         }
    1272             : 
    1273         500 :         if (!ext2_has_free_blocks(sbi)) {
    1274         100 :                 *errp = -ENOSPC;
    1275         100 :                 goto out;
    1276             :         }
    1277             : 
    1278             :         /*
    1279             :          * First, test whether the goal block is free.
    1280             :          */
    1281         600 :         if (goal < le32_to_cpu(es->s_first_data_block) ||
    1282             :             goal >= le32_to_cpu(es->s_blocks_count))
    1283         200 :                 goal = le32_to_cpu(es->s_first_data_block);
    1284         400 :         group_no = (goal - le32_to_cpu(es->s_first_data_block)) /
    1285             :                         EXT2_BLOCKS_PER_GROUP(sb);
    1286         100 :         goal_group = group_no;
    1287             : retry_alloc:
    1288         500 :         gdp = ext2_get_group_desc(sb, group_no, &gdp_bh);
    1289         200 :         if (!gdp)
    1290         100 :                 goto io_error;
    1291             : 
    1292         200 :         free_blocks = le16_to_cpu(gdp->bg_free_blocks_count);
    1293             :         /*
    1294             :          * if there is not enough free blocks to make a new resevation
    1295             :          * turn off reservation for this allocation
    1296             :          */
    1297        1000 :         if (my_rsv && (free_blocks < windowsz)
    1298             :                 && (free_blocks > 0)
    1299             :                 && (rsv_is_empty(&my_rsv->rsv_window)))
    1300         100 :                 my_rsv = NULL;
    1301             : 
    1302         400 :         if (free_blocks > 0) {
    1303         600 :                 grp_target_blk = ((goal - le32_to_cpu(es->s_first_data_block)) %
    1304             :                                 EXT2_BLOCKS_PER_GROUP(sb));
    1305         600 :                 bitmap_bh = read_block_bitmap(sb, group_no);
    1306         200 :                 if (!bitmap_bh)
    1307         100 :                         goto io_error;
    1308         400 :                 grp_alloc_blk = ext2_try_to_allocate_with_rsv(sb, group_no,
    1309             :                                         bitmap_bh, grp_target_blk,
    1310             :                                         my_rsv, &num);
    1311         200 :                 if (grp_alloc_blk >= 0)
    1312         100 :                         goto allocated;
    1313             :         }
    1314             : 
    1315         700 :         ngroups = EXT2_SB(sb)->s_groups_count;
    1316         100 :         smp_rmb();
    1317             : 
    1318             :         /*
    1319             :          * Now search the rest of the groups.  We assume that
    1320             :          * group_no and gdp correctly point to the last group visited.
    1321             :          */
    1322         600 :         for (bgi = 0; bgi < ngroups; bgi++) {
    1323         400 :                 group_no++;
    1324         300 :                 if (group_no >= ngroups)
    1325         100 :                         group_no = 0;
    1326         400 :                 gdp = ext2_get_group_desc(sb, group_no, &gdp_bh);
    1327         200 :                 if (!gdp)
    1328         100 :                         goto io_error;
    1329             : 
    1330         200 :                 free_blocks = le16_to_cpu(gdp->bg_free_blocks_count);
    1331             :                 /*
    1332             :                  * skip this group if the number of
    1333             :                  * free blocks is less than half of the reservation
    1334             :                  * window size.
    1335             :                  */
    1336         400 :                 if (my_rsv && (free_blocks <= (windowsz/2)))
    1337         100 :                         continue;
    1338             : 
    1339         200 :                 brelse(bitmap_bh);
    1340         600 :                 bitmap_bh = read_block_bitmap(sb, group_no);
    1341         200 :                 if (!bitmap_bh)
    1342         100 :                         goto io_error;
    1343             :                 /*
    1344             :                  * try to allocate block(s) from this group, without a goal(-1).
    1345             :                  */
    1346         400 :                 grp_alloc_blk = ext2_try_to_allocate_with_rsv(sb, group_no,
    1347             :                                         bitmap_bh, -1, my_rsv, &num);
    1348         200 :                 if (grp_alloc_blk >= 0)
    1349         100 :                         goto allocated;
    1350             :         }
    1351             :         /*
    1352             :          * We may end up a bogus ealier ENOSPC error due to
    1353         100 :          * filesystem is "full" of reservations, but
    1354             :          * there maybe indeed free blocks avaliable on disk
    1355             :          * In this case, we just forget about the reservations
    1356             :          * just do block allocation as without reservations.
    1357             :          */
    1358         200 :         if (my_rsv) {
    1359         100 :                 my_rsv = NULL;
    1360         100 :                 windowsz = 0;
    1361         100 :                 group_no = goal_group;
    1362         100 :                 goto retry_alloc;
    1363             :         }
    1364             :         /* No space left on the device */
    1365         100 :         *errp = -ENOSPC;
    1366         100 :         goto out;
    1367         200 : 
    1368             : allocated:
    1369             : 
    1370             :         ext2_debug("using block group %d(%d)\n",
    1371             :                         group_no, gdp->bg_free_blocks_count);
    1372             : 
    1373         500 :         ret_block = grp_alloc_blk + ext2_group_first_block_no(sb, group_no);
    1374             : 
    1375        3400 :         if (in_range(le32_to_cpu(gdp->bg_block_bitmap), ret_block, num) ||
    1376             :             in_range(le32_to_cpu(gdp->bg_inode_bitmap), ret_block, num) ||
    1377             :             in_range(ret_block, le32_to_cpu(gdp->bg_inode_table),
    1378         100 :                       EXT2_SB(sb)->s_itb_per_group) ||
    1379             :             in_range(ret_block + num - 1, le32_to_cpu(gdp->bg_inode_table),
    1380             :                       EXT2_SB(sb)->s_itb_per_group)) {
    1381         900 :                 ext2_error(sb, "ext2_new_blocks",
    1382             :                             "Allocating block in system zone - "
    1383             :                             "blocks from "E2FSBLK", length %lu",
    1384             :                             ret_block, num);
    1385             :                 /*
    1386             :                  * ext2_try_to_allocate marked the blocks we allocated as in
    1387             :                  * use.  So we may want to selectively mark some of the blocks
    1388             :                  * as free
    1389             :                  */
    1390         300 :                 goto retry_alloc;
    1391             :         }
    1392             : 
    1393         300 :         performed_allocation = 1;
    1394             : 
    1395         900 :         if (ret_block + num - 1 >= le32_to_cpu(es->s_blocks_count)) {
    1396         900 :                 ext2_error(sb, "ext2_new_blocks",
    1397             :                             "block("E2FSBLK") >= blocks count(%d) - "
    1398             :                             "block_group = %d, es == %p ", ret_block,
    1399             :                         le32_to_cpu(es->s_blocks_count), group_no, es);
    1400         100 :                 goto out;
    1401             :         }
    1402             : 
    1403         900 :         group_adjust_blocks(sb, group_no, gdp, gdp_bh, -num);
    1404         200 :         percpu_counter_sub(&sbi->s_freeblocks_counter, num);
    1405             : 
    1406         100 :         mark_buffer_dirty(bitmap_bh);
    1407         200 :         if (sb->s_flags & MS_SYNCHRONOUS)
    1408         100 :                 sync_dirty_buffer(bitmap_bh);
    1409             : 
    1410         100 :         *errp = 0;
    1411         200 :         brelse(bitmap_bh);
    1412         200 :         vfs_dq_free_block(inode, *count-num);
    1413         100 :         *count = num;
    1414         100 :         return ret_block;
    1415         400 : 
    1416             : io_error:
    1417         400 :         *errp = -EIO;
    1418         400 : out:
    1419             :         /*
    1420             :          * Undo the block allocation
    1421             :          */
    1422        1400 :         if (!performed_allocation)
    1423        1400 :                 vfs_dq_free_block(inode, *count);
    1424        1600 :         brelse(bitmap_bh);
    1425         100 :         return 0;
    1426             : }
    1427             : 
    1428             : ext2_fsblk_t ext2_new_block(struct inode *inode, unsigned long goal, int *errp)
    1429             : {
    1430         200 :         unsigned long count = 1;
    1431         100 : 
    1432         600 :         return ext2_new_blocks(inode, goal, &count, errp);
    1433             : }
    1434             : 
    1435             : #ifdef EXT2FS_DEBUG
    1436             : 
    1437             : static const int nibblemap[] = {4, 3, 3, 2, 3, 2, 2, 1, 3, 2, 2, 1, 2, 1, 1, 0};
    1438             : 
    1439             : unsigned long ext2_count_free (struct buffer_head * map, unsigned int numchars)
    1440             : {
    1441             :         unsigned int i;
    1442             :         unsigned long sum = 0;
    1443             : 
    1444             :         if (!map)
    1445             :                 return (0);
    1446             :         for (i = 0; i < numchars; i++)
    1447             :                 sum += nibblemap[map->b_data[i] & 0xf] +
    1448             :                         nibblemap[(map->b_data[i] >> 4) & 0xf];
    1449             :         return (sum);
    1450             : }
    1451             : 
    1452             : #endif  /*  EXT2FS_DEBUG  */
    1453             : 
    1454             : unsigned long ext2_count_free_blocks (struct super_block * sb)
    1455             : {
    1456        7001 :         struct ext2_group_desc * desc;
    1457       14002 :         unsigned long desc_count = 0;
    1458        7001 :         int i;
    1459        7001 : #ifdef EXT2FS_DEBUG
    1460             :         unsigned long bitmap_count, x;
    1461             :         struct ext2_super_block *es;
    1462             : 
    1463             :         es = EXT2_SB(sb)->s_es;
    1464             :         desc_count = 0;
    1465             :         bitmap_count = 0;
    1466             :         desc = NULL;
    1467             :         for (i = 0; i < EXT2_SB(sb)->s_groups_count; i++) {
    1468             :                 struct buffer_head *bitmap_bh;
    1469             :                 desc = ext2_get_group_desc (sb, i, NULL);
    1470             :                 if (!desc)
    1471             :                         continue;
    1472             :                 desc_count += le16_to_cpu(desc->bg_free_blocks_count);
    1473             :                 bitmap_bh = read_block_bitmap(sb, i);
    1474             :                 if (!bitmap_bh)
    1475             :                         continue;
    1476             :                 
    1477             :                 x = ext2_count_free(bitmap_bh, sb->s_blocksize);
    1478             :                 printk ("group %d: stored = %d, counted = %lu\n",
    1479             :                         i, le16_to_cpu(desc->bg_free_blocks_count), x);
    1480             :                 bitmap_count += x;
    1481             :                 brelse(bitmap_bh);
    1482             :         }
    1483             :         printk("ext2_count_free_blocks: stored = %lu, computed = %lu, %lu\n",
    1484             :                 (long)le32_to_cpu(es->s_free_blocks_count),
    1485             :                 desc_count, bitmap_count);
    1486             :         return bitmap_count;
    1487             : #else
    1488       49007 :         for (i = 0; i < EXT2_SB(sb)->s_groups_count; i++) {
    1489       34818 :                 desc = ext2_get_group_desc (sb, i, NULL);
    1490       21003 :                 if (!desc)
    1491        7001 :                         continue;
    1492       14002 :                 desc_count += le16_to_cpu(desc->bg_free_blocks_count);
    1493        7001 :         }
    1494        7001 :         return desc_count;
    1495             : #endif
    1496             : }
    1497             : 
    1498             : static inline int test_root(int a, int b)
    1499             : {
    1500          12 :         int num = b;
    1501             : 
    1502          18 :         while (a > num)
    1503          12 :                 num *= b;
    1504          18 :         return num == a;
    1505             : }
    1506             : 
    1507             : static int ext2_group_sparse(int group)
    1508             : {
    1509           6 :         if (group <= 1)
    1510           4 :                 return 1;
    1511          40 :         return (test_root(group, 3) || test_root(group, 5) ||
    1512           2 :                 test_root(group, 7));
    1513             : }
    1514             : 
    1515             : /**
    1516             :  *      ext2_bg_has_super - number of blocks used by the superblock in group
    1517             :  *      @sb: superblock for filesystem
    1518             :  *      @group: group number to check
    1519             :  *
    1520             :  *      Return the number of blocks used by the superblock (primary or backup)
    1521             :  *      in this group.  Currently this will be only 0 or 1.
    1522             :  */
    1523             : int ext2_bg_has_super(struct super_block *sb, int group)
    1524             : {
    1525          26 :         if (EXT2_HAS_RO_COMPAT_FEATURE(sb,EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER)&&
    1526           2 :             !ext2_group_sparse(group))
    1527           2 :                 return 0;
    1528           4 :         return 1;
    1529             : }
    1530             : 
    1531             : /**
    1532             :  *      ext2_bg_num_gdb - number of blocks used by the group table in group
    1533             :  *      @sb: superblock for filesystem
    1534             :  *      @group: group number to check
    1535             :  *
    1536             :  *      Return the number of blocks used by the group descriptor table
    1537             :  *      (primary or backup) in this group.  In the future there may be a
    1538             :  *      different number of descriptor blocks in each group.
    1539             :  */
    1540             : unsigned long ext2_bg_num_gdb(struct super_block *sb, int group)
    1541             : {
    1542          12 :         return ext2_bg_has_super(sb, group) ? EXT2_SB(sb)->s_gdb_count : 0;
    1543           1 : }
    1544           1 : 

Generated by: LCOV version 1.10