aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--fs/ext4/balloc.c1355
-rw-r--r--fs/ext4/ext4.h8
-rw-r--r--fs/ext4/ext4_i.h35
-rw-r--r--fs/ext4/ext4_sb.h1
-rw-r--r--fs/ext4/extents.c9
-rw-r--r--fs/ext4/file.c2
-rw-r--r--fs/ext4/ialloc.c1
-rw-r--r--fs/ext4/inode.c33
-rw-r--r--fs/ext4/ioctl.c44
-rw-r--r--fs/ext4/mballoc.c22
-rw-r--r--fs/ext4/resize.c18
-rw-r--r--fs/ext4/super.c40
12 files changed, 40 insertions, 1528 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
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index 922d18720c9e..c50c04cc6d7b 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -539,7 +539,6 @@ do { \
539#define EXT4_MOUNT_JOURNAL_CHECKSUM 0x800000 /* Journal checksums */ 539#define EXT4_MOUNT_JOURNAL_CHECKSUM 0x800000 /* Journal checksums */
540#define EXT4_MOUNT_JOURNAL_ASYNC_COMMIT 0x1000000 /* Journal Async Commit */ 540#define EXT4_MOUNT_JOURNAL_ASYNC_COMMIT 0x1000000 /* Journal Async Commit */
541#define EXT4_MOUNT_I_VERSION 0x2000000 /* i_version support */ 541#define EXT4_MOUNT_I_VERSION 0x2000000 /* i_version support */
542#define EXT4_MOUNT_MBALLOC 0x4000000 /* Buddy allocation support */
543#define EXT4_MOUNT_DELALLOC 0x8000000 /* Delalloc support */ 542#define EXT4_MOUNT_DELALLOC 0x8000000 /* Delalloc support */
544/* Compatibility, for having both ext2_fs.h and ext4_fs.h included at once */ 543/* Compatibility, for having both ext2_fs.h and ext4_fs.h included at once */
545#ifndef _LINUX_EXT2_FS_H 544#ifndef _LINUX_EXT2_FS_H
@@ -1002,8 +1001,6 @@ extern ext4_fsblk_t ext4_new_meta_blocks(handle_t *handle, struct inode *inode,
1002extern ext4_fsblk_t ext4_new_blocks(handle_t *handle, struct inode *inode, 1001extern ext4_fsblk_t ext4_new_blocks(handle_t *handle, struct inode *inode,
1003 ext4_lblk_t iblock, ext4_fsblk_t goal, 1002 ext4_lblk_t iblock, ext4_fsblk_t goal,
1004 unsigned long *count, int *errp); 1003 unsigned long *count, int *errp);
1005extern ext4_fsblk_t ext4_old_new_blocks(handle_t *handle, struct inode *inode,
1006 ext4_fsblk_t goal, unsigned long *count, int *errp);
1007extern int ext4_claim_free_blocks(struct ext4_sb_info *sbi, s64 nblocks); 1004extern int ext4_claim_free_blocks(struct ext4_sb_info *sbi, s64 nblocks);
1008extern ext4_fsblk_t ext4_has_free_blocks(struct ext4_sb_info *sbi, 1005extern ext4_fsblk_t ext4_has_free_blocks(struct ext4_sb_info *sbi,
1009 s64 nblocks); 1006 s64 nblocks);
@@ -1018,8 +1015,6 @@ extern struct ext4_group_desc * ext4_get_group_desc(struct super_block * sb,
1018 ext4_group_t block_group, 1015 ext4_group_t block_group,
1019 struct buffer_head ** bh); 1016 struct buffer_head ** bh);
1020extern int ext4_should_retry_alloc(struct super_block *sb, int *retries); 1017extern int ext4_should_retry_alloc(struct super_block *sb, int *retries);
1021extern void ext4_init_block_alloc_info(struct inode *);
1022extern void ext4_rsv_window_add(struct super_block *sb, struct ext4_reserve_window_node *rsv);
1023 1018
1024/* dir.c */ 1019/* dir.c */
1025extern int ext4_check_dir_entry(const char *, struct inode *, 1020extern int ext4_check_dir_entry(const char *, struct inode *,
@@ -1054,7 +1049,7 @@ extern int ext4_mb_release(struct super_block *);
1054extern ext4_fsblk_t ext4_mb_new_blocks(handle_t *, 1049extern ext4_fsblk_t ext4_mb_new_blocks(handle_t *,
1055 struct ext4_allocation_request *, int *); 1050 struct ext4_allocation_request *, int *);
1056extern int ext4_mb_reserve_blocks(struct super_block *, int); 1051extern int ext4_mb_reserve_blocks(struct super_block *, int);
1057extern void ext4_mb_discard_inode_preallocations(struct inode *); 1052extern void ext4_discard_preallocations(struct inode *);
1058extern int __init init_ext4_mballoc(void); 1053extern int __init init_ext4_mballoc(void);
1059extern void exit_ext4_mballoc(void); 1054extern void exit_ext4_mballoc(void);
1060extern void ext4_mb_free_blocks(handle_t *, struct inode *, 1055extern void ext4_mb_free_blocks(handle_t *, struct inode *,
@@ -1084,7 +1079,6 @@ extern int ext4_getattr(struct vfsmount *mnt, struct dentry *dentry,
1084 struct kstat *stat); 1079 struct kstat *stat);
1085extern void ext4_delete_inode(struct inode *); 1080extern void ext4_delete_inode(struct inode *);
1086extern int ext4_sync_inode(handle_t *, struct inode *); 1081extern int ext4_sync_inode(handle_t *, struct inode *);
1087extern void ext4_discard_reservation(struct inode *);
1088extern void ext4_dirty_inode(struct inode *); 1082extern void ext4_dirty_inode(struct inode *);
1089extern int ext4_change_inode_journal_flag(struct inode *, int); 1083extern int ext4_change_inode_journal_flag(struct inode *, int);
1090extern int ext4_get_inode_loc(struct inode *, struct ext4_iloc *); 1084extern int ext4_get_inode_loc(struct inode *, struct ext4_iloc *);
diff --git a/fs/ext4/ext4_i.h b/fs/ext4/ext4_i.h
index ef7409f0e7e4..2875eeca1727 100644
--- a/fs/ext4/ext4_i.h
+++ b/fs/ext4/ext4_i.h
@@ -33,38 +33,6 @@ typedef __u32 ext4_lblk_t;
33/* data type for block group number */ 33/* data type for block group number */
34typedef unsigned long ext4_group_t; 34typedef unsigned long ext4_group_t;
35 35
36struct ext4_reserve_window {
37 ext4_fsblk_t _rsv_start; /* First byte reserved */
38 ext4_fsblk_t _rsv_end; /* Last byte reserved or 0 */
39};
40
41struct ext4_reserve_window_node {
42 struct rb_node rsv_node;
43 __u32 rsv_goal_size;
44 __u32 rsv_alloc_hit;
45 struct ext4_reserve_window rsv_window;
46};
47
48struct ext4_block_alloc_info {
49 /* information about reservation window */
50 struct ext4_reserve_window_node rsv_window_node;
51 /*
52 * was i_next_alloc_block in ext4_inode_info
53 * is the logical (file-relative) number of the
54 * most-recently-allocated block in this file.
55 * We use this for detecting linearly ascending allocation requests.
56 */
57 ext4_lblk_t last_alloc_logical_block;
58 /*
59 * Was i_next_alloc_goal in ext4_inode_info
60 * is the *physical* companion to i_next_alloc_block.
61 * it the physical block number of the block which was most-recentl
62 * allocated to this file. This give us the goal (target) for the next
63 * allocation when we detect linearly ascending requests.
64 */
65 ext4_fsblk_t last_alloc_physical_block;
66};
67
68#define rsv_start rsv_window._rsv_start 36#define rsv_start rsv_window._rsv_start
69#define rsv_end rsv_window._rsv_end 37#define rsv_end rsv_window._rsv_end
70 38
@@ -97,9 +65,6 @@ struct ext4_inode_info {
97 ext4_group_t i_block_group; 65 ext4_group_t i_block_group;
98 __u32 i_state; /* Dynamic state flags for ext4 */ 66 __u32 i_state; /* Dynamic state flags for ext4 */
99 67
100 /* block reservation info */
101 struct ext4_block_alloc_info *i_block_alloc_info;
102
103 ext4_lblk_t i_dir_start_lookup; 68 ext4_lblk_t i_dir_start_lookup;
104#ifdef CONFIG_EXT4DEV_FS_XATTR 69#ifdef CONFIG_EXT4DEV_FS_XATTR
105 /* 70 /*
diff --git a/fs/ext4/ext4_sb.h b/fs/ext4/ext4_sb.h
index 94e0757522a6..6a0b40d43264 100644
--- a/fs/ext4/ext4_sb.h
+++ b/fs/ext4/ext4_sb.h
@@ -67,7 +67,6 @@ struct ext4_sb_info {
67 /* root of the per fs reservation window tree */ 67 /* root of the per fs reservation window tree */
68 spinlock_t s_rsv_window_lock; 68 spinlock_t s_rsv_window_lock;
69 struct rb_root s_rsv_window_root; 69 struct rb_root s_rsv_window_root;
70 struct ext4_reserve_window_node s_rsv_window_head;
71 70
72 /* Journaling */ 71 /* Journaling */
73 struct inode *s_journal_inode; 72 struct inode *s_journal_inode;
diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index e8758df2617b..c8f81f2fb28e 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -2697,11 +2697,8 @@ int ext4_ext_get_blocks(handle_t *handle, struct inode *inode,
2697 goto out2; 2697 goto out2;
2698 } 2698 }
2699 /* 2699 /*
2700 * Okay, we need to do block allocation. Lazily initialize the block 2700 * Okay, we need to do block allocation.
2701 * allocation info here if necessary.
2702 */ 2701 */
2703 if (S_ISREG(inode->i_mode) && (!EXT4_I(inode)->i_block_alloc_info))
2704 ext4_init_block_alloc_info(inode);
2705 2702
2706 /* find neighbour allocated blocks */ 2703 /* find neighbour allocated blocks */
2707 ar.lleft = iblock; 2704 ar.lleft = iblock;
@@ -2761,7 +2758,7 @@ int ext4_ext_get_blocks(handle_t *handle, struct inode *inode,
2761 /* free data blocks we just allocated */ 2758 /* free data blocks we just allocated */
2762 /* not a good idea to call discard here directly, 2759 /* not a good idea to call discard here directly,
2763 * but otherwise we'd need to call it every free() */ 2760 * but otherwise we'd need to call it every free() */
2764 ext4_mb_discard_inode_preallocations(inode); 2761 ext4_discard_preallocations(inode);
2765 ext4_free_blocks(handle, inode, ext_pblock(&newex), 2762 ext4_free_blocks(handle, inode, ext_pblock(&newex),
2766 ext4_ext_get_actual_len(&newex), 0); 2763 ext4_ext_get_actual_len(&newex), 0);
2767 goto out2; 2764 goto out2;
@@ -2825,7 +2822,7 @@ void ext4_ext_truncate(struct inode *inode)
2825 down_write(&EXT4_I(inode)->i_data_sem); 2822 down_write(&EXT4_I(inode)->i_data_sem);
2826 ext4_ext_invalidate_cache(inode); 2823 ext4_ext_invalidate_cache(inode);
2827 2824
2828 ext4_discard_reservation(inode); 2825 ext4_discard_preallocations(inode);
2829 2826
2830 /* 2827 /*
2831 * TODO: optimization is possible here. 2828 * TODO: optimization is possible here.
diff --git a/fs/ext4/file.c b/fs/ext4/file.c
index 11b289f42b7d..62796b7e1d1b 100644
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -38,7 +38,7 @@ static int ext4_release_file(struct inode *inode, struct file *filp)
38 (atomic_read(&inode->i_writecount) == 1)) 38 (atomic_read(&inode->i_writecount) == 1))
39 { 39 {
40 down_write(&EXT4_I(inode)->i_data_sem); 40 down_write(&EXT4_I(inode)->i_data_sem);
41 ext4_discard_reservation(inode); 41 ext4_discard_preallocations(inode);
42 up_write(&EXT4_I(inode)->i_data_sem); 42 up_write(&EXT4_I(inode)->i_data_sem);
43 } 43 }
44 if (is_dx(inode) && filp->private_data) 44 if (is_dx(inode) && filp->private_data)
diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index 5e66a2feef09..1343bf18825b 100644
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -817,7 +817,6 @@ got:
817 ei->i_flags &= ~EXT4_DIRSYNC_FL; 817 ei->i_flags &= ~EXT4_DIRSYNC_FL;
818 ei->i_file_acl = 0; 818 ei->i_file_acl = 0;
819 ei->i_dtime = 0; 819 ei->i_dtime = 0;
820 ei->i_block_alloc_info = NULL;
821 ei->i_block_group = group; 820 ei->i_block_group = group;
822 821
823 ext4_set_inode_flags(inode); 822 ext4_set_inode_flags(inode);
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index ef4ca3d4abc0..bd770c360c14 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -486,18 +486,9 @@ static ext4_fsblk_t ext4_find_near(struct inode *inode, Indirect *ind)
486static ext4_fsblk_t ext4_find_goal(struct inode *inode, ext4_lblk_t block, 486static ext4_fsblk_t ext4_find_goal(struct inode *inode, ext4_lblk_t block,
487 Indirect *partial) 487 Indirect *partial)
488{ 488{
489 struct ext4_block_alloc_info *block_i;
490
491 block_i = EXT4_I(inode)->i_block_alloc_info;
492
493 /* 489 /*
494 * try the heuristic for sequential allocation, 490 * XXX need to get goal block from mballoc's data structures
495 * failing that at least try to get decent locality.
496 */ 491 */
497 if (block_i && (block == block_i->last_alloc_logical_block + 1)
498 && (block_i->last_alloc_physical_block != 0)) {
499 return block_i->last_alloc_physical_block + 1;
500 }
501 492
502 return ext4_find_near(inode, partial); 493 return ext4_find_near(inode, partial);
503} 494}
@@ -757,10 +748,8 @@ static int ext4_splice_branch(handle_t *handle, struct inode *inode,
757{ 748{
758 int i; 749 int i;
759 int err = 0; 750 int err = 0;
760 struct ext4_block_alloc_info *block_i;
761 ext4_fsblk_t current_block; 751 ext4_fsblk_t current_block;
762 752
763 block_i = EXT4_I(inode)->i_block_alloc_info;
764 /* 753 /*
765 * If we're splicing into a [td]indirect block (as opposed to the 754 * If we're splicing into a [td]indirect block (as opposed to the
766 * inode) then we need to get write access to the [td]indirect block 755 * inode) then we need to get write access to the [td]indirect block
@@ -786,17 +775,6 @@ static int ext4_splice_branch(handle_t *handle, struct inode *inode,
786 *(where->p + i) = cpu_to_le32(current_block++); 775 *(where->p + i) = cpu_to_le32(current_block++);
787 } 776 }
788 777
789 /*
790 * update the most recently allocated logical & physical block
791 * in i_block_alloc_info, to assist find the proper goal block for next
792 * allocation
793 */
794 if (block_i) {
795 block_i->last_alloc_logical_block = block + blks - 1;
796 block_i->last_alloc_physical_block =
797 le32_to_cpu(where[num].key) + blks - 1;
798 }
799
800 /* We are done with atomic stuff, now do the rest of housekeeping */ 778 /* We are done with atomic stuff, now do the rest of housekeeping */
801 779
802 inode->i_ctime = ext4_current_time(inode); 780 inode->i_ctime = ext4_current_time(inode);
@@ -914,12 +892,8 @@ int ext4_get_blocks_handle(handle_t *handle, struct inode *inode,
914 goto cleanup; 892 goto cleanup;
915 893
916 /* 894 /*
917 * Okay, we need to do block allocation. Lazily initialize the block 895 * Okay, we need to do block allocation.
918 * allocation info here if necessary
919 */ 896 */
920 if (S_ISREG(inode->i_mode) && (!ei->i_block_alloc_info))
921 ext4_init_block_alloc_info(inode);
922
923 goal = ext4_find_goal(inode, iblock, partial); 897 goal = ext4_find_goal(inode, iblock, partial);
924 898
925 /* the number of blocks need to allocate for [d,t]indirect blocks */ 899 /* the number of blocks need to allocate for [d,t]indirect blocks */
@@ -3738,7 +3712,7 @@ void ext4_truncate(struct inode *inode)
3738 */ 3712 */
3739 down_write(&ei->i_data_sem); 3713 down_write(&ei->i_data_sem);
3740 3714
3741 ext4_discard_reservation(inode); 3715 ext4_discard_preallocations(inode);
3742 3716
3743 /* 3717 /*
3744 * The orphan list entry will now protect us from any crash which 3718 * The orphan list entry will now protect us from any crash which
@@ -4071,7 +4045,6 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
4071 ei->i_acl = EXT4_ACL_NOT_CACHED; 4045 ei->i_acl = EXT4_ACL_NOT_CACHED;
4072 ei->i_default_acl = EXT4_ACL_NOT_CACHED; 4046 ei->i_default_acl = EXT4_ACL_NOT_CACHED;
4073#endif 4047#endif
4074 ei->i_block_alloc_info = NULL;
4075 4048
4076 ret = __ext4_get_inode_loc(inode, &iloc, 0); 4049 ret = __ext4_get_inode_loc(inode, &iloc, 0);
4077 if (ret < 0) 4050 if (ret < 0)
diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c
index 3e14060b398e..ea27eaa0cfe5 100644
--- a/fs/ext4/ioctl.c
+++ b/fs/ext4/ioctl.c
@@ -23,7 +23,6 @@ long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
23 struct inode *inode = filp->f_dentry->d_inode; 23 struct inode *inode = filp->f_dentry->d_inode;
24 struct ext4_inode_info *ei = EXT4_I(inode); 24 struct ext4_inode_info *ei = EXT4_I(inode);
25 unsigned int flags; 25 unsigned int flags;
26 unsigned short rsv_window_size;
27 26
28 ext4_debug("cmd = %u, arg = %lu\n", cmd, arg); 27 ext4_debug("cmd = %u, arg = %lu\n", cmd, arg);
29 28
@@ -190,49 +189,6 @@ setversion_out:
190 return ret; 189 return ret;
191 } 190 }
192#endif 191#endif
193 case EXT4_IOC_GETRSVSZ:
194 if (test_opt(inode->i_sb, RESERVATION)
195 && S_ISREG(inode->i_mode)
196 && ei->i_block_alloc_info) {
197 rsv_window_size = ei->i_block_alloc_info->rsv_window_node.rsv_goal_size;
198 return put_user(rsv_window_size, (int __user *)arg);
199 }
200 return -ENOTTY;
201 case EXT4_IOC_SETRSVSZ: {
202 int err;
203
204 if (!test_opt(inode->i_sb, RESERVATION) || !S_ISREG(inode->i_mode))
205 return -ENOTTY;
206
207 if (!is_owner_or_cap(inode))
208 return -EACCES;
209
210 if (get_user(rsv_window_size, (int __user *)arg))
211 return -EFAULT;
212
213 err = mnt_want_write(filp->f_path.mnt);
214 if (err)
215 return err;
216
217 if (rsv_window_size > EXT4_MAX_RESERVE_BLOCKS)
218 rsv_window_size = EXT4_MAX_RESERVE_BLOCKS;
219
220 /*
221 * need to allocate reservation structure for this inode
222 * before set the window size
223 */
224 down_write(&ei->i_data_sem);
225 if (!ei->i_block_alloc_info)
226 ext4_init_block_alloc_info(inode);
227
228 if (ei->i_block_alloc_info){
229 struct ext4_reserve_window_node *rsv = &ei->i_block_alloc_info->rsv_window_node;
230 rsv->rsv_goal_size = rsv_window_size;
231 }
232 up_write(&ei->i_data_sem);
233 mnt_drop_write(filp->f_path.mnt);
234 return 0;
235 }
236 case EXT4_IOC_GROUP_EXTEND: { 192 case EXT4_IOC_GROUP_EXTEND: {
237 ext4_fsblk_t n_blocks_count; 193 ext4_fsblk_t n_blocks_count;
238 struct super_block *sb = inode->i_sb; 194 struct super_block *sb = inode->i_sb;
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index b9118bb29939..335faee0c0f5 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -534,9 +534,6 @@ static int __mb_check_buddy(struct ext4_buddy *e4b, char *file,
534 void *buddy; 534 void *buddy;
535 void *buddy2; 535 void *buddy2;
536 536
537 if (!test_opt(sb, MBALLOC))
538 return 0;
539
540 { 537 {
541 static int mb_check_counter; 538 static int mb_check_counter;
542 if (mb_check_counter++ % 100 != 0) 539 if (mb_check_counter++ % 100 != 0)
@@ -2487,19 +2484,14 @@ int ext4_mb_init(struct super_block *sb, int needs_recovery)
2487 unsigned max; 2484 unsigned max;
2488 int ret; 2485 int ret;
2489 2486
2490 if (!test_opt(sb, MBALLOC))
2491 return 0;
2492
2493 i = (sb->s_blocksize_bits + 2) * sizeof(unsigned short); 2487 i = (sb->s_blocksize_bits + 2) * sizeof(unsigned short);
2494 2488
2495 sbi->s_mb_offsets = kmalloc(i, GFP_KERNEL); 2489 sbi->s_mb_offsets = kmalloc(i, GFP_KERNEL);
2496 if (sbi->s_mb_offsets == NULL) { 2490 if (sbi->s_mb_offsets == NULL) {
2497 clear_opt(sbi->s_mount_opt, MBALLOC);
2498 return -ENOMEM; 2491 return -ENOMEM;
2499 } 2492 }
2500 sbi->s_mb_maxs = kmalloc(i, GFP_KERNEL); 2493 sbi->s_mb_maxs = kmalloc(i, GFP_KERNEL);
2501 if (sbi->s_mb_maxs == NULL) { 2494 if (sbi->s_mb_maxs == NULL) {
2502 clear_opt(sbi->s_mount_opt, MBALLOC);
2503 kfree(sbi->s_mb_maxs); 2495 kfree(sbi->s_mb_maxs);
2504 return -ENOMEM; 2496 return -ENOMEM;
2505 } 2497 }
@@ -2522,7 +2514,6 @@ int ext4_mb_init(struct super_block *sb, int needs_recovery)
2522 /* init file for buddy data */ 2514 /* init file for buddy data */
2523 ret = ext4_mb_init_backend(sb); 2515 ret = ext4_mb_init_backend(sb);
2524 if (ret != 0) { 2516 if (ret != 0) {
2525 clear_opt(sbi->s_mount_opt, MBALLOC);
2526 kfree(sbi->s_mb_offsets); 2517 kfree(sbi->s_mb_offsets);
2527 kfree(sbi->s_mb_maxs); 2518 kfree(sbi->s_mb_maxs);
2528 return ret; 2519 return ret;
@@ -2544,7 +2535,6 @@ int ext4_mb_init(struct super_block *sb, int needs_recovery)
2544 2535
2545 sbi->s_locality_groups = alloc_percpu(struct ext4_locality_group); 2536 sbi->s_locality_groups = alloc_percpu(struct ext4_locality_group);
2546 if (sbi->s_locality_groups == NULL) { 2537 if (sbi->s_locality_groups == NULL) {
2547 clear_opt(sbi->s_mount_opt, MBALLOC);
2548 kfree(sbi->s_mb_offsets); 2538 kfree(sbi->s_mb_offsets);
2549 kfree(sbi->s_mb_maxs); 2539 kfree(sbi->s_mb_maxs);
2550 return -ENOMEM; 2540 return -ENOMEM;
@@ -2590,9 +2580,6 @@ int ext4_mb_release(struct super_block *sb)
2590 struct ext4_group_info *grinfo; 2580 struct ext4_group_info *grinfo;
2591 struct ext4_sb_info *sbi = EXT4_SB(sb); 2581 struct ext4_sb_info *sbi = EXT4_SB(sb);
2592 2582
2593 if (!test_opt(sb, MBALLOC))
2594 return 0;
2595
2596 /* release freed, non-committed blocks */ 2583 /* release freed, non-committed blocks */
2597 spin_lock(&sbi->s_md_lock); 2584 spin_lock(&sbi->s_md_lock);
2598 list_splice_init(&sbi->s_closed_transaction, 2585 list_splice_init(&sbi->s_closed_transaction,
@@ -3805,7 +3792,7 @@ out:
3805 * 3792 *
3806 * FIXME!! Make sure it is valid at all the call sites 3793 * FIXME!! Make sure it is valid at all the call sites
3807 */ 3794 */
3808void ext4_mb_discard_inode_preallocations(struct inode *inode) 3795void ext4_discard_preallocations(struct inode *inode)
3809{ 3796{
3810 struct ext4_inode_info *ei = EXT4_I(inode); 3797 struct ext4_inode_info *ei = EXT4_I(inode);
3811 struct super_block *sb = inode->i_sb; 3798 struct super_block *sb = inode->i_sb;
@@ -3817,7 +3804,7 @@ void ext4_mb_discard_inode_preallocations(struct inode *inode)
3817 struct ext4_buddy e4b; 3804 struct ext4_buddy e4b;
3818 int err; 3805 int err;
3819 3806
3820 if (!test_opt(sb, MBALLOC) || !S_ISREG(inode->i_mode)) { 3807 if (!S_ISREG(inode->i_mode)) {
3821 /*BUG_ON(!list_empty(&ei->i_prealloc_list));*/ 3808 /*BUG_ON(!list_empty(&ei->i_prealloc_list));*/
3822 return; 3809 return;
3823 } 3810 }
@@ -4300,11 +4287,6 @@ ext4_fsblk_t ext4_mb_new_blocks(handle_t *handle,
4300 sb = ar->inode->i_sb; 4287 sb = ar->inode->i_sb;
4301 sbi = EXT4_SB(sb); 4288 sbi = EXT4_SB(sb);
4302 4289
4303 if (!test_opt(sb, MBALLOC)) {
4304 block = ext4_old_new_blocks(handle, ar->inode, ar->goal,
4305 &(ar->len), errp);
4306 return block;
4307 }
4308 if (!EXT4_I(ar->inode)->i_delalloc_reserved_flag) { 4290 if (!EXT4_I(ar->inode)->i_delalloc_reserved_flag) {
4309 /* 4291 /*
4310 * With delalloc we already reserved the blocks 4292 * With delalloc we already reserved the blocks
diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index b60afbcd7e46..b6ec1843a015 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -870,11 +870,10 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
870 * We can allocate memory for mb_alloc based on the new group 870 * We can allocate memory for mb_alloc based on the new group
871 * descriptor 871 * descriptor
872 */ 872 */
873 if (test_opt(sb, MBALLOC)) { 873 err = ext4_mb_add_more_groupinfo(sb, input->group, gdp);
874 err = ext4_mb_add_more_groupinfo(sb, input->group, gdp); 874 if (err)
875 if (err) 875 goto exit_journal;
876 goto exit_journal; 876
877 }
878 /* 877 /*
879 * Make the new blocks and inodes valid next. We do this before 878 * Make the new blocks and inodes valid next. We do this before
880 * increasing the group count so that once the group is enabled, 879 * increasing the group count so that once the group is enabled,
@@ -1086,8 +1085,15 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
1086 /* 1085 /*
1087 * Mark mballoc pages as not up to date so that they will be updated 1086 * Mark mballoc pages as not up to date so that they will be updated
1088 * next time they are loaded by ext4_mb_load_buddy. 1087 * next time they are loaded by ext4_mb_load_buddy.
1088 *
1089 * XXX Bad, Bad, BAD!!! We should not be overloading the
1090 * Uptodate flag, particularly on thte bitmap bh, as way of
1091 * hinting to ext4_mb_load_buddy() that it needs to be
1092 * overloaded. A user could take a LVM snapshot, then do an
1093 * on-line fsck, and clear the uptodate flag, and this would
1094 * not be a bug in userspace, but a bug in the kernel. FIXME!!!
1089 */ 1095 */
1090 if (test_opt(sb, MBALLOC)) { 1096 {
1091 struct ext4_sb_info *sbi = EXT4_SB(sb); 1097 struct ext4_sb_info *sbi = EXT4_SB(sb);
1092 struct inode *inode = sbi->s_buddy_cache; 1098 struct inode *inode = sbi->s_buddy_cache;
1093 int blocks_per_page; 1099 int blocks_per_page;
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 6583aee5177f..dfcd41fafb9f 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -574,7 +574,6 @@ static struct inode *ext4_alloc_inode(struct super_block *sb)
574 ei->i_acl = EXT4_ACL_NOT_CACHED; 574 ei->i_acl = EXT4_ACL_NOT_CACHED;
575 ei->i_default_acl = EXT4_ACL_NOT_CACHED; 575 ei->i_default_acl = EXT4_ACL_NOT_CACHED;
576#endif 576#endif
577 ei->i_block_alloc_info = NULL;
578 ei->vfs_inode.i_version = 1; 577 ei->vfs_inode.i_version = 1;
579 ei->vfs_inode.i_data.writeback_index = 0; 578 ei->vfs_inode.i_data.writeback_index = 0;
580 memset(&ei->i_cached_extent, 0, sizeof(struct ext4_ext_cache)); 579 memset(&ei->i_cached_extent, 0, sizeof(struct ext4_ext_cache));
@@ -633,7 +632,6 @@ static void destroy_inodecache(void)
633 632
634static void ext4_clear_inode(struct inode *inode) 633static void ext4_clear_inode(struct inode *inode)
635{ 634{
636 struct ext4_block_alloc_info *rsv = EXT4_I(inode)->i_block_alloc_info;
637#ifdef CONFIG_EXT4DEV_FS_POSIX_ACL 635#ifdef CONFIG_EXT4DEV_FS_POSIX_ACL
638 if (EXT4_I(inode)->i_acl && 636 if (EXT4_I(inode)->i_acl &&
639 EXT4_I(inode)->i_acl != EXT4_ACL_NOT_CACHED) { 637 EXT4_I(inode)->i_acl != EXT4_ACL_NOT_CACHED) {
@@ -646,10 +644,7 @@ static void ext4_clear_inode(struct inode *inode)
646 EXT4_I(inode)->i_default_acl = EXT4_ACL_NOT_CACHED; 644 EXT4_I(inode)->i_default_acl = EXT4_ACL_NOT_CACHED;
647 } 645 }
648#endif 646#endif
649 ext4_discard_reservation(inode); 647 ext4_discard_preallocations(inode);
650 EXT4_I(inode)->i_block_alloc_info = NULL;
651 if (unlikely(rsv))
652 kfree(rsv);
653 jbd2_journal_release_jbd_inode(EXT4_SB(inode->i_sb)->s_journal, 648 jbd2_journal_release_jbd_inode(EXT4_SB(inode->i_sb)->s_journal,
654 &EXT4_I(inode)->jinode); 649 &EXT4_I(inode)->jinode);
655} 650}
@@ -760,8 +755,6 @@ static int ext4_show_options(struct seq_file *seq, struct vfsmount *vfs)
760 seq_puts(seq, ",nobh"); 755 seq_puts(seq, ",nobh");
761 if (!test_opt(sb, EXTENTS)) 756 if (!test_opt(sb, EXTENTS))
762 seq_puts(seq, ",noextents"); 757 seq_puts(seq, ",noextents");
763 if (!test_opt(sb, MBALLOC))
764 seq_puts(seq, ",nomballoc");
765 if (test_opt(sb, I_VERSION)) 758 if (test_opt(sb, I_VERSION))
766 seq_puts(seq, ",i_version"); 759 seq_puts(seq, ",i_version");
767 if (!test_opt(sb, DELALLOC)) 760 if (!test_opt(sb, DELALLOC))
@@ -1373,12 +1366,6 @@ set_qf_format:
1373 case Opt_nodelalloc: 1366 case Opt_nodelalloc:
1374 clear_opt(sbi->s_mount_opt, DELALLOC); 1367 clear_opt(sbi->s_mount_opt, DELALLOC);
1375 break; 1368 break;
1376 case Opt_mballoc:
1377 set_opt(sbi->s_mount_opt, MBALLOC);
1378 break;
1379 case Opt_nomballoc:
1380 clear_opt(sbi->s_mount_opt, MBALLOC);
1381 break;
1382 case Opt_stripe: 1369 case Opt_stripe:
1383 if (match_int(&args[0], &option)) 1370 if (match_int(&args[0], &option))
1384 return 0; 1371 return 0;
@@ -2040,11 +2027,6 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
2040 ext4_warning(sb, __func__, 2027 ext4_warning(sb, __func__,
2041 "extents feature not enabled on this filesystem, " 2028 "extents feature not enabled on this filesystem, "
2042 "use tune2fs.\n"); 2029 "use tune2fs.\n");
2043 /*
2044 * turn on mballoc code by default in ext4 filesystem
2045 * Use -o nomballoc to turn it off
2046 */
2047 set_opt(sbi->s_mount_opt, MBALLOC);
2048 2030
2049 /* 2031 /*
2050 * enable delayed allocation by default 2032 * enable delayed allocation by default
@@ -2301,19 +2283,6 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
2301 goto failed_mount3; 2283 goto failed_mount3;
2302 } 2284 }
2303 2285
2304 /* per fileystem reservation list head & lock */
2305 spin_lock_init(&sbi->s_rsv_window_lock);
2306 sbi->s_rsv_window_root = RB_ROOT;
2307 /* Add a single, static dummy reservation to the start of the
2308 * reservation window list --- it gives us a placeholder for
2309 * append-at-start-of-list which makes the allocation logic
2310 * _much_ simpler. */
2311 sbi->s_rsv_window_head.rsv_start = EXT4_RESERVE_WINDOW_NOT_ALLOCATED;
2312 sbi->s_rsv_window_head.rsv_end = EXT4_RESERVE_WINDOW_NOT_ALLOCATED;
2313 sbi->s_rsv_window_head.rsv_alloc_hit = 0;
2314 sbi->s_rsv_window_head.rsv_goal_size = 0;
2315 ext4_rsv_window_add(sb, &sbi->s_rsv_window_head);
2316
2317 sbi->s_stripe = ext4_get_stripe_size(sbi); 2286 sbi->s_stripe = ext4_get_stripe_size(sbi);
2318 2287
2319 /* 2288 /*
@@ -2510,7 +2479,12 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
2510 printk(KERN_INFO "EXT4-fs: delayed allocation enabled\n"); 2479 printk(KERN_INFO "EXT4-fs: delayed allocation enabled\n");
2511 2480
2512 ext4_ext_init(sb); 2481 ext4_ext_init(sb);
2513 ext4_mb_init(sb, needs_recovery); 2482 err = ext4_mb_init(sb, needs_recovery);
2483 if (err) {
2484 printk(KERN_ERR "EXT4-fs: failed to initalize mballoc (%d)\n",
2485 err);
2486 goto failed_mount4;
2487 }
2514 2488
2515 lock_kernel(); 2489 lock_kernel();
2516 return 0; 2490 return 0;
generated by cgit v1.2.2 (git 2.25.0) at 2025-12-31 12:29:38 -0500