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