aboutsummaryrefslogtreecommitdiffstats
path: root/fs/ext4/balloc.c
diff options
context:
space:
mode:
authorTheodore Ts'o <tytso@mit.edu>2008-10-10 09:40:52 -0400
committerTheodore Ts'o <tytso@mit.edu>2008-10-10 09:40:52 -0400
commitc2ea3fde61f1df1dbf062345f23277dcd6f01dfe (patch)
tree53ecbf57416326810540494e814c05753bf30874 /fs/ext4/balloc.c
parent240799cdf22bd789ea6852653c3b879d35ad0a6c (diff)
ext4: Remove old legacy block allocator
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
Diffstat (limited to 'fs/ext4/balloc.c')
-rw-r--r--fs/ext4/balloc.c1355
1 files changed, 11 insertions, 1344 deletions
diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
index cca7fd53ad7b..59566c082f1b 100644
--- a/fs/ext4/balloc.c
+++ b/fs/ext4/balloc.c
@@ -83,6 +83,7 @@ static int ext4_group_used_meta_blocks(struct super_block *sb,
83 } 83 }
84 return used_blocks; 84 return used_blocks;
85} 85}
86
86/* Initializes an uninitialized block bitmap if given, and returns the 87/* Initializes an uninitialized block bitmap if given, and returns the
87 * number of blocks free in the group. */ 88 * number of blocks free in the group. */
88unsigned ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh, 89unsigned ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh,
@@ -345,303 +346,6 @@ ext4_read_block_bitmap(struct super_block *sb, ext4_group_t block_group)
345 */ 346 */
346 return bh; 347 return bh;
347} 348}
348/*
349 * The reservation window structure operations
350 * --------------------------------------------
351 * Operations include:
352 * dump, find, add, remove, is_empty, find_next_reservable_window, etc.
353 *
354 * We use a red-black tree to represent per-filesystem reservation
355 * windows.
356 *
357 */
358
359/**
360 * __rsv_window_dump() -- Dump the filesystem block allocation reservation map
361 * @rb_root: root of per-filesystem reservation rb tree
362 * @verbose: verbose mode
363 * @fn: function which wishes to dump the reservation map
364 *
365 * If verbose is turned on, it will print the whole block reservation
366 * windows(start, end). Otherwise, it will only print out the "bad" windows,
367 * those windows that overlap with their immediate neighbors.
368 */
369#if 1
370static void __rsv_window_dump(struct rb_root *root, int verbose,
371 const char *fn)
372{
373 struct rb_node *n;
374 struct ext4_reserve_window_node *rsv, *prev;
375 int bad;
376
377restart:
378 n = rb_first(root);
379 bad = 0;
380 prev = NULL;
381
382 printk(KERN_DEBUG "Block Allocation Reservation "
383 "Windows Map (%s):\n", fn);
384 while (n) {
385 rsv = rb_entry(n, struct ext4_reserve_window_node, rsv_node);
386 if (verbose)
387 printk(KERN_DEBUG "reservation window 0x%p "
388 "start: %llu, end: %llu\n",
389 rsv, rsv->rsv_start, rsv->rsv_end);
390 if (rsv->rsv_start && rsv->rsv_start >= rsv->rsv_end) {
391 printk(KERN_DEBUG "Bad reservation %p (start >= end)\n",
392 rsv);
393 bad = 1;
394 }
395 if (prev && prev->rsv_end >= rsv->rsv_start) {
396 printk(KERN_DEBUG "Bad reservation %p "
397 "(prev->end >= start)\n", rsv);
398 bad = 1;
399 }
400 if (bad) {
401 if (!verbose) {
402 printk(KERN_DEBUG "Restarting reservation "
403 "walk in verbose mode\n");
404 verbose = 1;
405 goto restart;
406 }
407 }
408 n = rb_next(n);
409 prev = rsv;
410 }
411 printk(KERN_DEBUG "Window map complete.\n");
412 BUG_ON(bad);
413}
414#define rsv_window_dump(root, verbose) \
415 __rsv_window_dump((root), (verbose), __func__)
416#else
417#define rsv_window_dump(root, verbose) do {} while (0)
418#endif
419
420/**
421 * goal_in_my_reservation()
422 * @rsv: inode's reservation window
423 * @grp_goal: given goal block relative to the allocation block group
424 * @group: the current allocation block group
425 * @sb: filesystem super block
426 *
427 * Test if the given goal block (group relative) is within the file's
428 * own block reservation window range.
429 *
430 * If the reservation window is outside the goal allocation group, return 0;
431 * grp_goal (given goal block) could be -1, which means no specific
432 * goal block. In this case, always return 1.
433 * If the goal block is within the reservation window, return 1;
434 * otherwise, return 0;
435 */
436static int
437goal_in_my_reservation(struct ext4_reserve_window *rsv, ext4_grpblk_t grp_goal,
438 ext4_group_t group, struct super_block *sb)
439{
440 ext4_fsblk_t group_first_block, group_last_block;
441
442 group_first_block = ext4_group_first_block_no(sb, group);
443 group_last_block = group_first_block + (EXT4_BLOCKS_PER_GROUP(sb) - 1);
444
445 if ((rsv->_rsv_start > group_last_block) ||
446 (rsv->_rsv_end < group_first_block))
447 return 0;
448 if ((grp_goal >= 0) && ((grp_goal + group_first_block < rsv->_rsv_start)
449 || (grp_goal + group_first_block > rsv->_rsv_end)))
450 return 0;
451 return 1;
452}
453
454/**
455 * search_reserve_window()
456 * @rb_root: root of reservation tree
457 * @goal: target allocation block
458 *
459 * Find the reserved window which includes the goal, or the previous one
460 * if the goal is not in any window.
461 * Returns NULL if there are no windows or if all windows start after the goal.
462 */
463static struct ext4_reserve_window_node *
464search_reserve_window(struct rb_root *root, ext4_fsblk_t goal)
465{
466 struct rb_node *n = root->rb_node;
467 struct ext4_reserve_window_node *rsv;
468
469 if (!n)
470 return NULL;
471
472 do {
473 rsv = rb_entry(n, struct ext4_reserve_window_node, rsv_node);
474
475 if (goal < rsv->rsv_start)
476 n = n->rb_left;
477 else if (goal > rsv->rsv_end)
478 n = n->rb_right;
479 else
480 return rsv;
481 } while (n);
482 /*
483 * We've fallen off the end of the tree: the goal wasn't inside
484 * any particular node. OK, the previous node must be to one
485 * side of the interval containing the goal. If it's the RHS,
486 * we need to back up one.
487 */
488 if (rsv->rsv_start > goal) {
489 n = rb_prev(&rsv->rsv_node);
490 rsv = rb_entry(n, struct ext4_reserve_window_node, rsv_node);
491 }
492 return rsv;
493}
494
495/**
496 * ext4_rsv_window_add() -- Insert a window to the block reservation rb tree.
497 * @sb: super block
498 * @rsv: reservation window to add
499 *
500 * Must be called with rsv_lock hold.
501 */
502void ext4_rsv_window_add(struct super_block *sb,
503 struct ext4_reserve_window_node *rsv)
504{
505 struct rb_root *root = &EXT4_SB(sb)->s_rsv_window_root;
506 struct rb_node *node = &rsv->rsv_node;
507 ext4_fsblk_t start = rsv->rsv_start;
508
509 struct rb_node **p = &root->rb_node;
510 struct rb_node *parent = NULL;
511 struct ext4_reserve_window_node *this;
512
513 while (*p)
514 {
515 parent = *p;
516 this = rb_entry(parent, struct ext4_reserve_window_node, rsv_node);
517
518 if (start < this->rsv_start)
519 p = &(*p)->rb_left;
520 else if (start > this->rsv_end)
521 p = &(*p)->rb_right;
522 else {
523 rsv_window_dump(root, 1);
524 BUG();
525 }
526 }
527
528 rb_link_node(node, parent, p);
529 rb_insert_color(node, root);
530}
531
532/**
533 * ext4_rsv_window_remove() -- unlink a window from the reservation rb tree
534 * @sb: super block
535 * @rsv: reservation window to remove
536 *
537 * Mark the block reservation window as not allocated, and unlink it
538 * from the filesystem reservation window rb tree. Must be called with
539 * rsv_lock hold.
540 */
541static void rsv_window_remove(struct super_block *sb,
542 struct ext4_reserve_window_node *rsv)
543{
544 rsv->rsv_start = EXT4_RESERVE_WINDOW_NOT_ALLOCATED;
545 rsv->rsv_end = EXT4_RESERVE_WINDOW_NOT_ALLOCATED;
546 rsv->rsv_alloc_hit = 0;
547 rb_erase(&rsv->rsv_node, &EXT4_SB(sb)->s_rsv_window_root);
548}
549
550/*
551 * rsv_is_empty() -- Check if the reservation window is allocated.
552 * @rsv: given reservation window to check
553 *
554 * returns 1 if the end block is EXT4_RESERVE_WINDOW_NOT_ALLOCATED.
555 */
556static inline int rsv_is_empty(struct ext4_reserve_window *rsv)
557{
558 /* a valid reservation end block could not be 0 */
559 return rsv->_rsv_end == EXT4_RESERVE_WINDOW_NOT_ALLOCATED;
560}
561
562/**
563 * ext4_init_block_alloc_info()
564 * @inode: file inode structure
565 *
566 * Allocate and initialize the reservation window structure, and
567 * link the window to the ext4 inode structure at last
568 *
569 * The reservation window structure is only dynamically allocated
570 * and linked to ext4 inode the first time the open file
571 * needs a new block. So, before every ext4_new_block(s) call, for
572 * regular files, we should check whether the reservation window
573 * structure exists or not. In the latter case, this function is called.
574 * Fail to do so will result in block reservation being turned off for that
575 * open file.
576 *
577 * This function is called from ext4_get_blocks_handle(), also called
578 * when setting the reservation window size through ioctl before the file
579 * is open for write (needs block allocation).
580 *
581 * Needs down_write(i_data_sem) protection prior to call this function.
582 */
583void ext4_init_block_alloc_info(struct inode *inode)
584{
585 struct ext4_inode_info *ei = EXT4_I(inode);
586 struct ext4_block_alloc_info *block_i = ei->i_block_alloc_info;
587 struct super_block *sb = inode->i_sb;
588
589 block_i = kmalloc(sizeof(*block_i), GFP_NOFS);
590 if (block_i) {
591 struct ext4_reserve_window_node *rsv = &block_i->rsv_window_node;
592
593 rsv->rsv_start = EXT4_RESERVE_WINDOW_NOT_ALLOCATED;
594 rsv->rsv_end = EXT4_RESERVE_WINDOW_NOT_ALLOCATED;
595
596 /*
597 * if filesystem is mounted with NORESERVATION, the goal
598 * reservation window size is set to zero to indicate
599 * block reservation is off
600 */
601 if (!test_opt(sb, RESERVATION))
602 rsv->rsv_goal_size = 0;
603 else
604 rsv->rsv_goal_size = EXT4_DEFAULT_RESERVE_BLOCKS;
605 rsv->rsv_alloc_hit = 0;
606 block_i->last_alloc_logical_block = 0;
607 block_i->last_alloc_physical_block = 0;
608 }
609 ei->i_block_alloc_info = block_i;
610}
611
612/**
613 * ext4_discard_reservation()
614 * @inode: inode
615 *
616 * Discard(free) block reservation window on last file close, or truncate
617 * or at last iput().
618 *
619 * It is being called in three cases:
620 * ext4_release_file(): last writer close the file
621 * ext4_clear_inode(): last iput(), when nobody link to this file.
622 * ext4_truncate(): when the block indirect map is about to change.
623 *
624 */
625void ext4_discard_reservation(struct inode *inode)
626{
627 struct ext4_inode_info *ei = EXT4_I(inode);
628 struct ext4_block_alloc_info *block_i = ei->i_block_alloc_info;
629 struct ext4_reserve_window_node *rsv;
630 spinlock_t *rsv_lock = &EXT4_SB(inode->i_sb)->s_rsv_window_lock;
631
632 ext4_mb_discard_inode_preallocations(inode);
633
634 if (!block_i)
635 return;
636
637 rsv = &block_i->rsv_window_node;
638 if (!rsv_is_empty(&rsv->rsv_window)) {
639 spin_lock(rsv_lock);
640 if (!rsv_is_empty(&rsv->rsv_window))
641 rsv_window_remove(inode->i_sb, rsv);
642 spin_unlock(rsv_lock);
643 }
644}
645 349
646/** 350/**
647 * ext4_free_blocks_sb() -- Free given blocks and update quota 351 * ext4_free_blocks_sb() -- Free given blocks and update quota
@@ -650,6 +354,13 @@ void ext4_discard_reservation(struct inode *inode)
650 * @block: start physcial block to free 354 * @block: start physcial block to free
651 * @count: number of blocks to free 355 * @count: number of blocks to free
652 * @pdquot_freed_blocks: pointer to quota 356 * @pdquot_freed_blocks: pointer to quota
357 *
358 * XXX This function is only used by the on-line resizing code, which
359 * should probably be fixed up to call the mballoc variant. There
360 * this needs to be cleaned up later; in fact, I'm not convinced this
361 * is 100% correct in the face of the mballoc code. The online resizing
362 * code needs to be fixed up to more tightly (and correctly) interlock
363 * with the mballoc code.
653 */ 364 */
654void ext4_free_blocks_sb(handle_t *handle, struct super_block *sb, 365void ext4_free_blocks_sb(handle_t *handle, struct super_block *sb,
655 ext4_fsblk_t block, unsigned long count, 366 ext4_fsblk_t block, unsigned long count,
@@ -861,747 +572,13 @@ void ext4_free_blocks(handle_t *handle, struct inode *inode,
861 572
862 sb = inode->i_sb; 573 sb = inode->i_sb;
863 574
864 if (!test_opt(sb, MBALLOC) || !EXT4_SB(sb)->s_group_info) 575 ext4_mb_free_blocks(handle, inode, block, count,
865 ext4_free_blocks_sb(handle, sb, block, count, 576 metadata, &dquot_freed_blocks);
866 &dquot_freed_blocks);
867 else
868 ext4_mb_free_blocks(handle, inode, block, count,
869 metadata, &dquot_freed_blocks);
870 if (dquot_freed_blocks) 577 if (dquot_freed_blocks)
871 DQUOT_FREE_BLOCK(inode, dquot_freed_blocks); 578 DQUOT_FREE_BLOCK(inode, dquot_freed_blocks);
872 return; 579 return;
873} 580}
874 581
875/**
876 * ext4_test_allocatable()
877 * @nr: given allocation block group
878 * @bh: bufferhead contains the bitmap of the given block group
879 *
880 * For ext4 allocations, we must not reuse any blocks which are
881 * allocated in the bitmap buffer's "last committed data" copy. This
882 * prevents deletes from freeing up the page for reuse until we have
883 * committed the delete transaction.
884 *
885 * If we didn't do this, then deleting something and reallocating it as
886 * data would allow the old block to be overwritten before the
887 * transaction committed (because we force data to disk before commit).
888 * This would lead to corruption if we crashed between overwriting the
889 * data and committing the delete.
890 *
891 * @@@ We may want to make this allocation behaviour conditional on
892 * data-writes at some point, and disable it for metadata allocations or
893 * sync-data inodes.
894 */
895static int ext4_test_allocatable(ext4_grpblk_t nr, struct buffer_head *bh)
896{
897 int ret;
898 struct journal_head *jh = bh2jh(bh);
899
900 if (ext4_test_bit(nr, bh->b_data))
901 return 0;
902
903 jbd_lock_bh_state(bh);
904 if (!jh->b_committed_data)
905 ret = 1;
906 else
907 ret = !ext4_test_bit(nr, jh->b_committed_data);
908 jbd_unlock_bh_state(bh);
909 return ret;
910}
911
912/**
913 * bitmap_search_next_usable_block()
914 * @start: the starting block (group relative) of the search
915 * @bh: bufferhead contains the block group bitmap
916 * @maxblocks: the ending block (group relative) of the reservation
917 *
918 * The bitmap search --- search forward alternately through the actual
919 * bitmap on disk and the last-committed copy in journal, until we find a
920 * bit free in both bitmaps.
921 */
922static ext4_grpblk_t
923bitmap_search_next_usable_block(ext4_grpblk_t start, struct buffer_head *bh,
924 ext4_grpblk_t maxblocks)
925{
926 ext4_grpblk_t next;
927 struct journal_head *jh = bh2jh(bh);
928
929 while (start < maxblocks) {
930 next = ext4_find_next_zero_bit(bh->b_data, maxblocks, start);
931 if (next >= maxblocks)
932 return -1;
933 if (ext4_test_allocatable(next, bh))
934 return next;
935 jbd_lock_bh_state(bh);
936 if (jh->b_committed_data)
937 start = ext4_find_next_zero_bit(jh->b_committed_data,
938 maxblocks, next);
939 jbd_unlock_bh_state(bh);
940 }
941 return -1;
942}
943
944/**
945 * find_next_usable_block()
946 * @start: the starting block (group relative) to find next
947 * allocatable block in bitmap.
948 * @bh: bufferhead contains the block group bitmap
949 * @maxblocks: the ending block (group relative) for the search
950 *
951 * Find an allocatable block in a bitmap. We honor both the bitmap and
952 * its last-committed copy (if that exists), and perform the "most
953 * appropriate allocation" algorithm of looking for a free block near
954 * the initial goal; then for a free byte somewhere in the bitmap; then
955 * for any free bit in the bitmap.
956 */
957static ext4_grpblk_t
958find_next_usable_block(ext4_grpblk_t start, struct buffer_head *bh,
959 ext4_grpblk_t maxblocks)
960{
961 ext4_grpblk_t here, next;
962 char *p, *r;
963
964 if (start > 0) {
965 /*
966 * The goal was occupied; search forward for a free
967 * block within the next XX blocks.
968 *
969 * end_goal is more or less random, but it has to be
970 * less than EXT4_BLOCKS_PER_GROUP. Aligning up to the
971 * next 64-bit boundary is simple..
972 */
973 ext4_grpblk_t end_goal = (start + 63) & ~63;
974 if (end_goal > maxblocks)
975 end_goal = maxblocks;
976 here = ext4_find_next_zero_bit(bh->b_data, end_goal, start);
977 if (here < end_goal && ext4_test_allocatable(here, bh))
978 return here;
979 ext4_debug("Bit not found near goal\n");
980 }
981
982 here = start;
983 if (here < 0)
984 here = 0;
985
986 p = ((char *)bh->b_data) + (here >> 3);
987 r = memscan(p, 0, ((maxblocks + 7) >> 3) - (here >> 3));
988 next = (r - ((char *)bh->b_data)) << 3;
989
990 if (next < maxblocks && next >= start && ext4_test_allocatable(next, bh))
991 return next;
992
993 /*
994 * The bitmap search --- search forward alternately through the actual
995 * bitmap and the last-committed copy until we find a bit free in
996 * both
997 */
998 here = bitmap_search_next_usable_block(here, bh, maxblocks);
999 return here;
1000}
1001
1002/**
1003 * claim_block()
1004 * @block: the free block (group relative) to allocate
1005 * @bh: the bufferhead containts the block group bitmap
1006 *
1007 * We think we can allocate this block in this bitmap. Try to set the bit.
1008 * If that succeeds then check that nobody has allocated and then freed the
1009 * block since we saw that is was not marked in b_committed_data. If it _was_
1010 * allocated and freed then clear the bit in the bitmap again and return
1011 * zero (failure).
1012 */
1013static inline int
1014claim_block(spinlock_t *lock, ext4_grpblk_t block, struct buffer_head *bh)
1015{
1016 struct journal_head *jh = bh2jh(bh);
1017 int ret;
1018
1019 if (ext4_set_bit_atomic(lock, block, bh->b_data))
1020 return 0;
1021 jbd_lock_bh_state(bh);
1022 if (jh->b_committed_data && ext4_test_bit(block, jh->b_committed_data)) {
1023 ext4_clear_bit_atomic(lock, block, bh->b_data);
1024 ret = 0;
1025 } else {
1026 ret = 1;
1027 }
1028 jbd_unlock_bh_state(bh);
1029 return ret;
1030}
1031
1032/**
1033 * ext4_try_to_allocate()
1034 * @sb: superblock
1035 * @handle: handle to this transaction
1036 * @group: given allocation block group
1037 * @bitmap_bh: bufferhead holds the block bitmap
1038 * @grp_goal: given target block within the group
1039 * @count: target number of blocks to allocate
1040 * @my_rsv: reservation window
1041 *
1042 * Attempt to allocate blocks within a give range. Set the range of allocation
1043 * first, then find the first free bit(s) from the bitmap (within the range),
1044 * and at last, allocate the blocks by claiming the found free bit as allocated.
1045 *
1046 * To set the range of this allocation:
1047 * if there is a reservation window, only try to allocate block(s) from the
1048 * file's own reservation window;
1049 * Otherwise, the allocation range starts from the give goal block, ends at
1050 * the block group's last block.
1051 *
1052 * If we failed to allocate the desired block then we may end up crossing to a
1053 * new bitmap. In that case we must release write access to the old one via
1054 * ext4_journal_release_buffer(), else we'll run out of credits.
1055 */
1056static ext4_grpblk_t
1057ext4_try_to_allocate(struct super_block *sb, handle_t *handle,
1058 ext4_group_t group, struct buffer_head *bitmap_bh,
1059 ext4_grpblk_t grp_goal, unsigned long *count,
1060 struct ext4_reserve_window *my_rsv)
1061{
1062 ext4_fsblk_t group_first_block;
1063 ext4_grpblk_t start, end;
1064 unsigned long num = 0;
1065
1066 /* we do allocation within the reservation window if we have a window */
1067 if (my_rsv) {
1068 group_first_block = ext4_group_first_block_no(sb, group);
1069 if (my_rsv->_rsv_start >= group_first_block)
1070 start = my_rsv->_rsv_start - group_first_block;
1071 else
1072 /* reservation window cross group boundary */
1073 start = 0;
1074 end = my_rsv->_rsv_end - group_first_block + 1;
1075 if (end > EXT4_BLOCKS_PER_GROUP(sb))
1076 /* reservation window crosses group boundary */
1077 end = EXT4_BLOCKS_PER_GROUP(sb);
1078 if ((start <= grp_goal) && (grp_goal < end))
1079 start = grp_goal;
1080 else
1081 grp_goal = -1;
1082 } else {
1083 if (grp_goal > 0)
1084 start = grp_goal;
1085 else
1086 start = 0;
1087 end = EXT4_BLOCKS_PER_GROUP(sb);
1088 }
1089
1090 BUG_ON(start > EXT4_BLOCKS_PER_GROUP(sb));
1091
1092repeat:
1093 if (grp_goal < 0 || !ext4_test_allocatable(grp_goal, bitmap_bh)) {
1094 grp_goal = find_next_usable_block(start, bitmap_bh, end);
1095 if (grp_goal < 0)
1096 goto fail_access;
1097 if (!my_rsv) {
1098 int i;
1099
1100 for (i = 0; i < 7 && grp_goal > start &&
1101 ext4_test_allocatable(grp_goal - 1,
1102 bitmap_bh);
1103 i++, grp_goal--)
1104 ;
1105 }
1106 }
1107 start = grp_goal;
1108
1109 if (!claim_block(sb_bgl_lock(EXT4_SB(sb), group),
1110 grp_goal, bitmap_bh)) {
1111 /*
1112 * The block was allocated by another thread, or it was
1113 * allocated and then freed by another thread
1114 */
1115 start++;
1116 grp_goal++;
1117 if (start >= end)
1118 goto fail_access;
1119 goto repeat;
1120 }
1121 num++;
1122 grp_goal++;
1123 while (num < *count && grp_goal < end
1124 && ext4_test_allocatable(grp_goal, bitmap_bh)
1125 && claim_block(sb_bgl_lock(EXT4_SB(sb), group),
1126 grp_goal, bitmap_bh)) {
1127 num++;
1128 grp_goal++;
1129 }
1130 *count = num;
1131 return grp_goal - num;
1132fail_access:
1133 *count = num;
1134 return -1;
1135}
1136
1137/**
1138 * find_next_reservable_window():
1139 * find a reservable space within the given range.
1140 * It does not allocate the reservation window for now:
1141 * alloc_new_reservation() will do the work later.
1142 *
1143 * @search_head: the head of the searching list;
1144 * This is not necessarily the list head of the whole filesystem
1145 *
1146 * We have both head and start_block to assist the search
1147 * for the reservable space. The list starts from head,
1148 * but we will shift to the place where start_block is,
1149 * then start from there, when looking for a reservable space.
1150 *
1151 * @size: the target new reservation window size
1152 *
1153 * @group_first_block: the first block we consider to start
1154 * the real search from
1155 *
1156 * @last_block:
1157 * the maximum block number that our goal reservable space
1158 * could start from. This is normally the last block in this
1159 * group. The search will end when we found the start of next
1160 * possible reservable space is out of this boundary.
1161 * This could handle the cross boundary reservation window
1162 * request.
1163 *
1164 * basically we search from the given range, rather than the whole
1165 * reservation double linked list, (start_block, last_block)
1166 * to find a free region that is of my size and has not
1167 * been reserved.
1168 *
1169 */
1170static int find_next_reservable_window(
1171 struct ext4_reserve_window_node *search_head,
1172 struct ext4_reserve_window_node *my_rsv,
1173 struct super_block *sb,
1174 ext4_fsblk_t start_block,
1175 ext4_fsblk_t last_block)
1176{
1177 struct rb_node *next;
1178 struct ext4_reserve_window_node *rsv, *prev;
1179 ext4_fsblk_t cur;
1180 int size = my_rsv->rsv_goal_size;
1181
1182 /* TODO: make the start of the reservation window byte-aligned */
1183 /* cur = *start_block & ~7;*/
1184 cur = start_block;
1185 rsv = search_head;
1186 if (!rsv)
1187 return -1;
1188
1189 while (1) {
1190 if (cur <= rsv->rsv_end)
1191 cur = rsv->rsv_end + 1;
1192
1193 /* TODO?
1194 * in the case we could not find a reservable space
1195 * that is what is expected, during the re-search, we could
1196 * remember what's the largest reservable space we could have
1197 * and return that one.
1198 *
1199 * For now it will fail if we could not find the reservable
1200 * space with expected-size (or more)...
1201 */
1202 if (cur > last_block)
1203 return -1; /* fail */
1204
1205 prev = rsv;
1206 next = rb_next(&rsv->rsv_node);
1207 rsv = rb_entry(next, struct ext4_reserve_window_node, rsv_node);
1208
1209 /*
1210 * Reached the last reservation, we can just append to the
1211 * previous one.
1212 */
1213 if (!next)
1214 break;
1215
1216 if (cur + size <= rsv->rsv_start) {
1217 /*
1218 * Found a reserveable space big enough. We could
1219 * have a reservation across the group boundary here
1220 */
1221 break;
1222 }
1223 }
1224 /*
1225 * we come here either :
1226 * when we reach the end of the whole list,
1227 * and there is empty reservable space after last entry in the list.
1228 * append it to the end of the list.
1229 *
1230 * or we found one reservable space in the middle of the list,
1231 * return the reservation window that we could append to.
1232 * succeed.
1233 */
1234
1235 if ((prev != my_rsv) && (!rsv_is_empty(&my_rsv->rsv_window)))
1236 rsv_window_remove(sb, my_rsv);
1237
1238 /*
1239 * Let's book the whole avaliable window for now. We will check the
1240 * disk bitmap later and then, if there are free blocks then we adjust
1241 * the window size if it's larger than requested.
1242 * Otherwise, we will remove this node from the tree next time
1243 * call find_next_reservable_window.
1244 */
1245 my_rsv->rsv_start = cur;
1246 my_rsv->rsv_end = cur + size - 1;
1247 my_rsv->rsv_alloc_hit = 0;
1248
1249 if (prev != my_rsv)
1250 ext4_rsv_window_add(sb, my_rsv);
1251
1252 return 0;
1253}
1254
1255/**
1256 * alloc_new_reservation()--allocate a new reservation window
1257 *
1258 * To make a new reservation, we search part of the filesystem
1259 * reservation list (the list that inside the group). We try to
1260 * allocate a new reservation window near the allocation goal,
1261 * or the beginning of the group, if there is no goal.
1262 *
1263 * We first find a reservable space after the goal, then from
1264 * there, we check the bitmap for the first free block after
1265 * it. If there is no free block until the end of group, then the
1266 * whole group is full, we failed. Otherwise, check if the free
1267 * block is inside the expected reservable space, if so, we
1268 * succeed.
1269 * If the first free block is outside the reservable space, then
1270 * start from the first free block, we search for next available
1271 * space, and go on.
1272 *
1273 * on succeed, a new reservation will be found and inserted into the list
1274 * It contains at least one free block, and it does not overlap with other
1275 * reservation windows.
1276 *
1277 * failed: we failed to find a reservation window in this group
1278 *
1279 * @rsv: the reservation
1280 *
1281 * @grp_goal: The goal (group-relative). It is where the search for a
1282 * free reservable space should start from.
1283 * if we have a grp_goal(grp_goal >0 ), then start from there,
1284 * no grp_goal(grp_goal = -1), we start from the first block
1285 * of the group.
1286 *
1287 * @sb: the super block
1288 * @group: the group we are trying to allocate in
1289 * @bitmap_bh: the block group block bitmap
1290 *
1291 */
1292static int alloc_new_reservation(struct ext4_reserve_window_node *my_rsv,
1293 ext4_grpblk_t grp_goal, struct super_block *sb,
1294 ext4_group_t group, struct buffer_head *bitmap_bh)
1295{
1296 struct ext4_reserve_window_node *search_head;
1297 ext4_fsblk_t group_first_block, group_end_block, start_block;
1298 ext4_grpblk_t first_free_block;
1299 struct rb_root *fs_rsv_root = &EXT4_SB(sb)->s_rsv_window_root;
1300 unsigned long size;
1301 int ret;
1302 spinlock_t *rsv_lock = &EXT4_SB(sb)->s_rsv_window_lock;
1303
1304 group_first_block = ext4_group_first_block_no(sb, group);
1305 group_end_block = group_first_block + (EXT4_BLOCKS_PER_GROUP(sb) - 1);
1306
1307 if (grp_goal < 0)
1308 start_block = group_first_block;
1309 else
1310 start_block = grp_goal + group_first_block;
1311
1312 size = my_rsv->rsv_goal_size;
1313
1314 if (!rsv_is_empty(&my_rsv->rsv_window)) {
1315 /*
1316 * if the old reservation is cross group boundary
1317 * and if the goal is inside the old reservation window,
1318 * we will come here when we just failed to allocate from
1319 * the first part of the window. We still have another part
1320 * that belongs to the next group. In this case, there is no
1321 * point to discard our window and try to allocate a new one
1322 * in this group(which will fail). we should
1323 * keep the reservation window, just simply move on.
1324 *
1325 * Maybe we could shift the start block of the reservation
1326 * window to the first block of next group.
1327 */
1328
1329 if ((my_rsv->rsv_start <= group_end_block) &&
1330 (my_rsv->rsv_end > group_end_block) &&
1331 (start_block >= my_rsv->rsv_start))
1332 return -1;
1333
1334 if ((my_rsv->rsv_alloc_hit >
1335 (my_rsv->rsv_end - my_rsv->rsv_start + 1) / 2)) {
1336 /*
1337 * if the previously allocation hit ratio is
1338 * greater than 1/2, then we double the size of
1339 * the reservation window the next time,
1340 * otherwise we keep the same size window
1341 */
1342 size = size * 2;
1343 if (size > EXT4_MAX_RESERVE_BLOCKS)
1344 size = EXT4_MAX_RESERVE_BLOCKS;
1345 my_rsv->rsv_goal_size = size;
1346 }
1347 }
1348
1349 spin_lock(rsv_lock);
1350 /*
1351 * shift the search start to the window near the goal block
1352 */
1353 search_head = search_reserve_window(fs_rsv_root, start_block);
1354
1355 /*
1356 * find_next_reservable_window() simply finds a reservable window
1357 * inside the given range(start_block, group_end_block).
1358 *
1359 * To make sure the reservation window has a free bit inside it, we
1360 * need to check the bitmap after we found a reservable window.
1361 */
1362retry:
1363 ret = find_next_reservable_window(search_head, my_rsv, sb,
1364 start_block, group_end_block);
1365
1366 if (ret == -1) {
1367 if (!rsv_is_empty(&my_rsv->rsv_window))
1368 rsv_window_remove(sb, my_rsv);
1369 spin_unlock(rsv_lock);
1370 return -1;
1371 }
1372
1373 /*
1374 * On success, find_next_reservable_window() returns the
1375 * reservation window where there is a reservable space after it.
1376 * Before we reserve this reservable space, we need
1377 * to make sure there is at least a free block inside this region.
1378 *
1379 * searching the first free bit on the block bitmap and copy of
1380 * last committed bitmap alternatively, until we found a allocatable
1381 * block. Search start from the start block of the reservable space
1382 * we just found.
1383 */
1384 spin_unlock(rsv_lock);
1385 first_free_block = bitmap_search_next_usable_block(
1386 my_rsv->rsv_start - group_first_block,
1387 bitmap_bh, group_end_block - group_first_block + 1);
1388
1389 if (first_free_block < 0) {
1390 /*
1391 * no free block left on the bitmap, no point
1392 * to reserve the space. return failed.
1393 */
1394 spin_lock(rsv_lock);
1395 if (!rsv_is_empty(&my_rsv->rsv_window))
1396 rsv_window_remove(sb, my_rsv);
1397 spin_unlock(rsv_lock);
1398 return -1; /* failed */
1399 }
1400
1401 start_block = first_free_block + group_first_block;
1402 /*
1403 * check if the first free block is within the
1404 * free space we just reserved
1405 */
1406 if (start_block >= my_rsv->rsv_start && start_block <= my_rsv->rsv_end)
1407 return 0; /* success */
1408 /*
1409 * if the first free bit we found is out of the reservable space
1410 * continue search for next reservable space,
1411 * start from where the free block is,
1412 * we also shift the list head to where we stopped last time
1413 */
1414 search_head = my_rsv;
1415 spin_lock(rsv_lock);
1416 goto retry;
1417}
1418
1419/**
1420 * try_to_extend_reservation()
1421 * @my_rsv: given reservation window
1422 * @sb: super block
1423 * @size: the delta to extend
1424 *
1425 * Attempt to expand the reservation window large enough to have
1426 * required number of free blocks
1427 *
1428 * Since ext4_try_to_allocate() will always allocate blocks within
1429 * the reservation window range, if the window size is too small,
1430 * multiple blocks allocation has to stop at the end of the reservation
1431 * window. To make this more efficient, given the total number of
1432 * blocks needed and the current size of the window, we try to
1433 * expand the reservation window size if necessary on a best-effort
1434 * basis before ext4_new_blocks() tries to allocate blocks,
1435 */
1436static void try_to_extend_reservation(struct ext4_reserve_window_node *my_rsv,
1437 struct super_block *sb, int size)
1438{
1439 struct ext4_reserve_window_node *next_rsv;
1440 struct rb_node *next;
1441 spinlock_t *rsv_lock = &EXT4_SB(sb)->s_rsv_window_lock;
1442
1443 if (!spin_trylock(rsv_lock))
1444 return;
1445
1446 next = rb_next(&my_rsv->rsv_node);
1447
1448 if (!next)
1449 my_rsv->rsv_end += size;
1450 else {
1451 next_rsv = rb_entry(next, struct ext4_reserve_window_node, rsv_node);
1452
1453 if ((next_rsv->rsv_start - my_rsv->rsv_end - 1) >= size)
1454 my_rsv->rsv_end += size;
1455 else
1456 my_rsv->rsv_end = next_rsv->rsv_start - 1;
1457 }
1458 spin_unlock(rsv_lock);
1459}
1460
1461/**
1462 * ext4_try_to_allocate_with_rsv()
1463 * @sb: superblock
1464 * @handle: handle to this transaction
1465 * @group: given allocation block group
1466 * @bitmap_bh: bufferhead holds the block bitmap
1467 * @grp_goal: given target block within the group
1468 * @count: target number of blocks to allocate
1469 * @my_rsv: reservation window
1470 * @errp: pointer to store the error code
1471 *
1472 * This is the main function used to allocate a new block and its reservation
1473 * window.
1474 *
1475 * Each time when a new block allocation is need, first try to allocate from
1476 * its own reservation. If it does not have a reservation window, instead of
1477 * looking for a free bit on bitmap first, then look up the reservation list to
1478 * see if it is inside somebody else's reservation window, we try to allocate a
1479 * reservation window for it starting from the goal first. Then do the block
1480 * allocation within the reservation window.
1481 *
1482 * This will avoid keeping on searching the reservation list again and
1483 * again when somebody is looking for a free block (without
1484 * reservation), and there are lots of free blocks, but they are all
1485 * being reserved.
1486 *
1487 * We use a red-black tree for the per-filesystem reservation list.
1488 *
1489 */
1490static ext4_grpblk_t
1491ext4_try_to_allocate_with_rsv(struct super_block *sb, handle_t *handle,
1492 ext4_group_t group, struct buffer_head *bitmap_bh,
1493 ext4_grpblk_t grp_goal,
1494 struct ext4_reserve_window_node *my_rsv,
1495 unsigned long *count, int *errp)
1496{
1497 ext4_fsblk_t group_first_block, group_last_block;
1498 ext4_grpblk_t ret = 0;
1499 int fatal;
1500 unsigned long num = *count;
1501
1502 *errp = 0;
1503
1504 /*
1505 * Make sure we use undo access for the bitmap, because it is critical
1506 * that we do the frozen_data COW on bitmap buffers in all cases even
1507 * if the buffer is in BJ_Forget state in the committing transaction.
1508 */
1509 BUFFER_TRACE(bitmap_bh, "get undo access for new block");
1510 fatal = ext4_journal_get_undo_access(handle, bitmap_bh);
1511 if (fatal) {
1512 *errp = fatal;
1513 return -1;
1514 }
1515
1516 /*
1517 * we don't deal with reservation when
1518 * filesystem is mounted without reservation
1519 * or the file is not a regular file
1520 * or last attempt to allocate a block with reservation turned on failed
1521 */
1522 if (my_rsv == NULL) {
1523 ret = ext4_try_to_allocate(sb, handle, group, bitmap_bh,
1524 grp_goal, count, NULL);
1525 goto out;
1526 }
1527 /*
1528 * grp_goal is a group relative block number (if there is a goal)
1529 * 0 <= grp_goal < EXT4_BLOCKS_PER_GROUP(sb)
1530 * first block is a filesystem wide block number
1531 * first block is the block number of the first block in this group
1532 */
1533 group_first_block = ext4_group_first_block_no(sb, group);
1534 group_last_block = group_first_block + (EXT4_BLOCKS_PER_GROUP(sb) - 1);
1535
1536 /*
1537 * Basically we will allocate a new block from inode's reservation
1538 * window.
1539 *
1540 * We need to allocate a new reservation window, if:
1541 * a) inode does not have a reservation window; or
1542 * b) last attempt to allocate a block from existing reservation
1543 * failed; or
1544 * c) we come here with a goal and with a reservation window
1545 *
1546 * We do not need to allocate a new reservation window if we come here
1547 * at the beginning with a goal and the goal is inside the window, or
1548 * we don't have a goal but already have a reservation window.
1549 * then we could go to allocate from the reservation window directly.
1550 */
1551 while (1) {
1552 if (rsv_is_empty(&my_rsv->rsv_window) || (ret < 0) ||
1553 !goal_in_my_reservation(&my_rsv->rsv_window,
1554 grp_goal, group, sb)) {
1555 if (my_rsv->rsv_goal_size < *count)
1556 my_rsv->rsv_goal_size = *count;
1557 ret = alloc_new_reservation(my_rsv, grp_goal, sb,
1558 group, bitmap_bh);
1559 if (ret < 0)
1560 break; /* failed */
1561
1562 if (!goal_in_my_reservation(&my_rsv->rsv_window,
1563 grp_goal, group, sb))
1564 grp_goal = -1;
1565 } else if (grp_goal >= 0) {
1566 int curr = my_rsv->rsv_end -
1567 (grp_goal + group_first_block) + 1;
1568
1569 if (curr < *count)
1570 try_to_extend_reservation(my_rsv, sb,
1571 *count - curr);
1572 }
1573
1574 if ((my_rsv->rsv_start > group_last_block) ||
1575 (my_rsv->rsv_end < group_first_block)) {
1576 rsv_window_dump(&EXT4_SB(sb)->s_rsv_window_root, 1);
1577 BUG();
1578 }
1579 ret = ext4_try_to_allocate(sb, handle, group, bitmap_bh,
1580 grp_goal, &num, &my_rsv->rsv_window);
1581 if (ret >= 0) {
1582 my_rsv->rsv_alloc_hit += num;
1583 *count = num;
1584 break; /* succeed */
1585 }
1586 num = *count;
1587 }
1588out:
1589 if (ret >= 0) {
1590 BUFFER_TRACE(bitmap_bh, "journal_dirty_metadata for "
1591 "bitmap block");
1592 fatal = ext4_journal_dirty_metadata(handle, bitmap_bh);
1593 if (fatal) {
1594 *errp = fatal;
1595 return -1;
1596 }
1597 return ret;
1598 }
1599
1600 BUFFER_TRACE(bitmap_bh, "journal_release_buffer");
1601 ext4_journal_release_buffer(handle, bitmap_bh);
1602 return ret;
1603}
1604
1605int ext4_claim_free_blocks(struct ext4_sb_info *sbi, 582int ext4_claim_free_blocks(struct ext4_sb_info *sbi,
1606 s64 nblocks) 583 s64 nblocks)
1607{ 584{
@@ -1702,313 +679,6 @@ int ext4_should_retry_alloc(struct super_block *sb, int *retries)
1702 return jbd2_journal_force_commit_nested(EXT4_SB(sb)->s_journal); 679 return jbd2_journal_force_commit_nested(EXT4_SB(sb)->s_journal);
1703} 680}
1704 681
1705/**
1706 * ext4_old_new_blocks() -- core block bitmap based block allocation function
1707 *
1708 * @handle: handle to this transaction
1709 * @inode: file inode
1710 * @goal: given target block(filesystem wide)
1711 * @count: target number of blocks to allocate
1712 * @errp: error code
1713 *
1714 * ext4_old_new_blocks uses a goal block to assist allocation and look up
1715 * the block bitmap directly to do block allocation. It tries to
1716 * allocate block(s) from the block group contains the goal block first. If
1717 * that fails, it will try to allocate block(s) from other block groups
1718 * without any specific goal block.
1719 *
1720 * This function is called when -o nomballoc mount option is enabled
1721 *
1722 */
1723ext4_fsblk_t ext4_old_new_blocks(handle_t *handle, struct inode *inode,
1724 ext4_fsblk_t goal, unsigned long *count, int *errp)
1725{
1726 struct buffer_head *bitmap_bh = NULL;
1727 struct buffer_head *gdp_bh;
1728 ext4_group_t group_no;
1729 ext4_group_t goal_group;
1730 ext4_grpblk_t grp_target_blk; /* blockgroup relative goal block */
1731 ext4_grpblk_t grp_alloc_blk; /* blockgroup-relative allocated block*/
1732 ext4_fsblk_t ret_block; /* filesyetem-wide allocated block */
1733 ext4_group_t bgi; /* blockgroup iteration index */
1734 int fatal = 0, err;
1735 int performed_allocation = 0;
1736 ext4_grpblk_t free_blocks; /* number of free blocks in a group */
1737 struct super_block *sb;
1738 struct ext4_group_desc *gdp;
1739 struct ext4_super_block *es;
1740 struct ext4_sb_info *sbi;
1741 struct ext4_reserve_window_node *my_rsv = NULL;
1742 struct ext4_block_alloc_info *block_i;
1743 unsigned short windowsz = 0;
1744 ext4_group_t ngroups;
1745 unsigned long num = *count;
1746
1747 sb = inode->i_sb;
1748 if (!sb) {
1749 *errp = -ENODEV;
1750 printk(KERN_ERR "ext4_new_block: nonexistent superblock");
1751 return 0;
1752 }
1753
1754 sbi = EXT4_SB(sb);
1755 if (!EXT4_I(inode)->i_delalloc_reserved_flag) {
1756 /*
1757 * With delalloc we already reserved the blocks
1758 */
1759 while (*count && ext4_claim_free_blocks(sbi, *count)) {
1760 /* let others to free the space */
1761 yield();
1762 *count = *count >> 1;
1763 }
1764 if (!*count) {
1765 *errp = -ENOSPC;
1766 return 0; /*return with ENOSPC error */
1767 }
1768 num = *count;
1769 }
1770 /*
1771 * Check quota for allocation of this block.
1772 */
1773 if (DQUOT_ALLOC_BLOCK(inode, num)) {
1774 *errp = -EDQUOT;
1775 return 0;
1776 }
1777
1778 sbi = EXT4_SB(sb);
1779 es = EXT4_SB(sb)->s_es;
1780 ext4_debug("goal=%llu.\n", goal);
1781 /*
1782 * Allocate a block from reservation only when
1783 * filesystem is mounted with reservation(default,-o reservation), and
1784 * it's a regular file, and
1785 * the desired window size is greater than 0 (One could use ioctl
1786 * command EXT4_IOC_SETRSVSZ to set the window size to 0 to turn off
1787 * reservation on that particular file)
1788 */
1789 block_i = EXT4_I(inode)->i_block_alloc_info;
1790 if (block_i && ((windowsz = block_i->rsv_window_node.rsv_goal_size) > 0))
1791 my_rsv = &block_i->rsv_window_node;
1792
1793 /*
1794 * First, test whether the goal block is free.
1795 */
1796 if (goal < le32_to_cpu(es->s_first_data_block) ||
1797 goal >= ext4_blocks_count(es))
1798 goal = le32_to_cpu(es->s_first_data_block);
1799 ext4_get_group_no_and_offset(sb, goal, &group_no, &grp_target_blk);
1800 goal_group = group_no;
1801retry_alloc:
1802 gdp = ext4_get_group_desc(sb, group_no, &gdp_bh);
1803 if (!gdp)
1804 goto io_error;
1805
1806 free_blocks = le16_to_cpu(gdp->bg_free_blocks_count);
1807
1808 if (free_blocks > 0) {
1809 /*
1810 * try to allocate with group target block
1811 * in the goal group. If we have low free_blocks
1812 * count turn off reservation
1813 */
1814 if (my_rsv && (free_blocks < windowsz)
1815 && (rsv_is_empty(&my_rsv->rsv_window)))
1816 my_rsv = NULL;
1817
1818 bitmap_bh = ext4_read_block_bitmap(sb, group_no);
1819 if (!bitmap_bh)
1820 goto io_error;
1821 grp_alloc_blk = ext4_try_to_allocate_with_rsv(sb, handle,
1822 group_no, bitmap_bh, grp_target_blk,
1823 my_rsv, &num, &fatal);
1824 if (fatal)
1825 goto out;
1826 if (grp_alloc_blk >= 0)
1827 goto allocated;
1828 }
1829
1830 ngroups = EXT4_SB(sb)->s_groups_count;
1831 smp_rmb();
1832
1833 /*
1834 * Now search the rest of the groups. We assume that
1835 * group_no and gdp correctly point to the last group visited.
1836 */
1837 for (bgi = 0; bgi < ngroups; bgi++) {
1838 group_no++;
1839 if (group_no >= ngroups)
1840 group_no = 0;
1841 gdp = ext4_get_group_desc(sb, group_no, &gdp_bh);
1842 if (!gdp)
1843 goto io_error;
1844 free_blocks = le16_to_cpu(gdp->bg_free_blocks_count);
1845 /*
1846 * skip this group if the number of
1847 * free blocks is less than half of the reservation
1848 * window size.
1849 */
1850 if (my_rsv && (free_blocks <= (windowsz/2)))
1851 continue;
1852
1853 brelse(bitmap_bh);
1854 bitmap_bh = ext4_read_block_bitmap(sb, group_no);
1855 if (!bitmap_bh)
1856 goto io_error;
1857 /*
1858 * try to allocate block(s) from this group, without a goal(-1).
1859 */
1860 grp_alloc_blk = ext4_try_to_allocate_with_rsv(sb, handle,
1861 group_no, bitmap_bh, -1, my_rsv,
1862 &num, &fatal);
1863 if (fatal)
1864 goto out;
1865 if (grp_alloc_blk >= 0)
1866 goto allocated;
1867 }
1868 /*
1869 * We may end up a bogus ealier ENOSPC error due to
1870 * filesystem is "full" of reservations, but
1871 * there maybe indeed free blocks avaliable on disk
1872 * In this case, we just forget about the reservations
1873 * just do block allocation as without reservations.
1874 */
1875 if (my_rsv) {
1876 my_rsv = NULL;
1877 windowsz = 0;
1878 group_no = goal_group;
1879 goto retry_alloc;
1880 }
1881 /* No space left on the device */
1882 *errp = -ENOSPC;
1883 goto out;
1884
1885allocated:
1886
1887 ext4_debug("using block group %lu(%d)\n",
1888 group_no, gdp->bg_free_blocks_count);
1889
1890 BUFFER_TRACE(gdp_bh, "get_write_access");
1891 fatal = ext4_journal_get_write_access(handle, gdp_bh);
1892 if (fatal)
1893 goto out;
1894
1895 ret_block = grp_alloc_blk + ext4_group_first_block_no(sb, group_no);
1896
1897 if (in_range(ext4_block_bitmap(sb, gdp), ret_block, num) ||
1898 in_range(ext4_inode_bitmap(sb, gdp), ret_block, num) ||
1899 in_range(ret_block, ext4_inode_table(sb, gdp),
1900 EXT4_SB(sb)->s_itb_per_group) ||
1901 in_range(ret_block + num - 1, ext4_inode_table(sb, gdp),
1902 EXT4_SB(sb)->s_itb_per_group)) {
1903 ext4_error(sb, "ext4_new_block",
1904 "Allocating block in system zone - "
1905 "blocks from %llu, length %lu",
1906 ret_block, num);
1907 /*
1908 * claim_block marked the blocks we allocated
1909 * as in use. So we may want to selectively
1910 * mark some of the blocks as free
1911 */
1912 goto retry_alloc;
1913 }
1914
1915 performed_allocation = 1;
1916
1917#ifdef CONFIG_JBD2_DEBUG
1918 {
1919 struct buffer_head *debug_bh;
1920
1921 /* Record bitmap buffer state in the newly allocated block */
1922 debug_bh = sb_find_get_block(sb, ret_block);
1923 if (debug_bh) {
1924 BUFFER_TRACE(debug_bh, "state when allocated");
1925 BUFFER_TRACE2(debug_bh, bitmap_bh, "bitmap state");
1926 brelse(debug_bh);
1927 }
1928 }
1929 jbd_lock_bh_state(bitmap_bh);
1930 spin_lock(sb_bgl_lock(sbi, group_no));
1931 if (buffer_jbd(bitmap_bh) && bh2jh(bitmap_bh)->b_committed_data) {
1932 int i;
1933
1934 for (i = 0; i < num; i++) {
1935 if (ext4_test_bit(grp_alloc_blk+i,
1936 bh2jh(bitmap_bh)->b_committed_data)) {
1937 printk(KERN_ERR "%s: block was unexpectedly "
1938 "set in b_committed_data\n", __func__);
1939 }
1940 }
1941 }
1942 ext4_debug("found bit %d\n", grp_alloc_blk);
1943 spin_unlock(sb_bgl_lock(sbi, group_no));
1944 jbd_unlock_bh_state(bitmap_bh);
1945#endif
1946
1947 if (ret_block + num - 1 >= ext4_blocks_count(es)) {
1948 ext4_error(sb, "ext4_new_block",
1949 "block(%llu) >= blocks count(%llu) - "
1950 "block_group = %lu, es == %p ", ret_block,
1951 ext4_blocks_count(es), group_no, es);
1952 goto out;
1953 }
1954
1955 /*
1956 * It is up to the caller to add the new buffer to a journal
1957 * list of some description. We don't know in advance whether
1958 * the caller wants to use it as metadata or data.
1959 */
1960 spin_lock(sb_bgl_lock(sbi, group_no));
1961 if (gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT))
1962 gdp->bg_flags &= cpu_to_le16(~EXT4_BG_BLOCK_UNINIT);
1963 le16_add_cpu(&gdp->bg_free_blocks_count, -num);
1964 gdp->bg_checksum = ext4_group_desc_csum(sbi, group_no, gdp);
1965 spin_unlock(sb_bgl_lock(sbi, group_no));
1966 percpu_counter_sub(&sbi->s_freeblocks_counter, num);
1967 /*
1968 * Now reduce the dirty block count also. Should not go negative
1969 */
1970 if (!EXT4_I(inode)->i_delalloc_reserved_flag)
1971 percpu_counter_sub(&sbi->s_dirtyblocks_counter, *count);
1972 else
1973 percpu_counter_sub(&sbi->s_dirtyblocks_counter, num);
1974 if (sbi->s_log_groups_per_flex) {
1975 ext4_group_t flex_group = ext4_flex_group(sbi, group_no);
1976 spin_lock(sb_bgl_lock(sbi, flex_group));
1977 sbi->s_flex_groups[flex_group].free_blocks -= num;
1978 spin_unlock(sb_bgl_lock(sbi, flex_group));
1979 }
1980
1981 BUFFER_TRACE(gdp_bh, "journal_dirty_metadata for group descriptor");
1982 err = ext4_journal_dirty_metadata(handle, gdp_bh);
1983 if (!fatal)
1984 fatal = err;
1985
1986 sb->s_dirt = 1;
1987 if (fatal)
1988 goto out;
1989
1990 *errp = 0;
1991 brelse(bitmap_bh);
1992 DQUOT_FREE_BLOCK(inode, *count-num);
1993 *count = num;
1994 return ret_block;
1995
1996io_error:
1997 *errp = -EIO;
1998out:
1999 if (fatal) {
2000 *errp = fatal;
2001 ext4_std_error(sb, fatal);
2002 }
2003 /*
2004 * Undo the block allocation
2005 */
2006 if (!performed_allocation)
2007 DQUOT_FREE_BLOCK(inode, *count);
2008 brelse(bitmap_bh);
2009 return 0;
2010}
2011
2012#define EXT4_META_BLOCK 0x1 682#define EXT4_META_BLOCK 0x1
2013 683
2014static ext4_fsblk_t do_blk_alloc(handle_t *handle, struct inode *inode, 684static ext4_fsblk_t do_blk_alloc(handle_t *handle, struct inode *inode,
@@ -2018,10 +688,6 @@ static ext4_fsblk_t do_blk_alloc(handle_t *handle, struct inode *inode,
2018 struct ext4_allocation_request ar; 688 struct ext4_allocation_request ar;
2019 ext4_fsblk_t ret; 689 ext4_fsblk_t ret;
2020 690
2021 if (!test_opt(inode->i_sb, MBALLOC)) {
2022 return ext4_old_new_blocks(handle, inode, goal, count, errp);
2023 }
2024
2025 memset(&ar, 0, sizeof(ar)); 691 memset(&ar, 0, sizeof(ar));
2026 /* Fill with neighbour allocated blocks */ 692 /* Fill with neighbour allocated blocks */
2027 693
@@ -2242,3 +908,4 @@ unsigned long ext4_bg_num_gdb(struct super_block *sb, ext4_group_t group)
2242 return ext4_bg_num_gdb_meta(sb,group); 908 return ext4_bg_num_gdb_meta(sb,group);
2243 909
2244} 910}
911
generated by cgit v1.2.2 (git 2.25.0) at 2024-09-20 08:17:58 -0400